Enum swc_plugin::utils::swc_common::pass::Either
source · [−]pub enum Either<L, R> {
Left(L),
Right(R),
}
Expand description
The enum Either
with variants Left
and Right
is a general purpose
sum type with two cases.
The Either
type is symmetric and treats its variants the same way, without
preference.
(For representing success or error, use the regular Result
enum instead.)
Variants
Left(L)
A value of type L
.
Right(R)
A value of type R
.
Implementations
sourceimpl<L, R> Either<L, R>
impl<L, R> Either<L, R>
sourcepub fn is_left(&self) -> bool
pub fn is_left(&self) -> bool
Return true if the value is the Left
variant.
use either::*;
let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_left(), true);
assert_eq!(values[1].is_left(), false);
sourcepub fn is_right(&self) -> bool
pub fn is_right(&self) -> bool
Return true if the value is the Right
variant.
use either::*;
let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_right(), false);
assert_eq!(values[1].is_right(), true);
sourcepub fn left(self) -> Option<L>
pub fn left(self) -> Option<L>
Convert the left side of Either<L, R>
to an Option<L>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.left(), Some("some value"));
let right: Either<(), _> = Right(321);
assert_eq!(right.left(), None);
sourcepub fn right(self) -> Option<R>
pub fn right(self) -> Option<R>
Convert the right side of Either<L, R>
to an Option<R>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.right(), None);
let right: Either<(), _> = Right(321);
assert_eq!(right.right(), Some(321));
sourcepub fn as_ref(&self) -> Either<&L, &R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
pub fn as_ref(&self) -> Either<&L, &R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Convert &Either<L, R>
to Either<&L, &R>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));
let right: Either<(), _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));
sourcepub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
pub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Convert &mut Either<L, R>
to Either<&mut L, &mut R>
.
use either::*;
fn mutate_left(value: &mut Either<u32, u32>) {
if let Some(l) = value.as_mut().left() {
*l = 999;
}
}
let mut left = Left(123);
let mut right = Right(123);
mutate_left(&mut left);
mutate_left(&mut right);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));
sourcepub fn flip(self) -> Either<R, L>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
pub fn flip(self) -> Either<R, L>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Convert Either<L, R>
to Either<R, L>
.
use either::*;
let left: Either<_, ()> = Left(123);
assert_eq!(left.flip(), Right(123));
let right: Either<(), _> = Right("some value");
assert_eq!(right.flip(), Left("some value"));
sourcepub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(L) -> M,
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(L) -> M,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Apply the function f
on the value in the Left
variant if it is present rewrapping the
result in Left
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_left(|x| x * 2), Left(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_left(|x| x * 2), Right(123));
sourcepub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(R) -> S,
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(R) -> S,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_right(|x| x * 2), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_right(|x| x * 2), Right(246));
sourcepub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
Apply one of two functions depending on contents, unifying their result. If the value is
Left(L)
then the first function f
is applied; if it is Right(R)
then the second
function g
is applied.
use either::*;
fn square(n: u32) -> i32 { (n * n) as i32 }
fn negate(n: i32) -> i32 { -n }
let left: Either<u32, i32> = Left(4);
assert_eq!(left.either(square, negate), 16);
let right: Either<u32, i32> = Right(-4);
assert_eq!(right.either(square, negate), 4);
sourcepub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
Like either
, but provide some context to whichever of the
functions ends up being called.
// In this example, the context is a mutable reference
use either::*;
let mut result = Vec::new();
let values = vec![Left(2), Right(2.7)];
for value in values {
value.either_with(&mut result,
|ctx, integer| ctx.push(integer),
|ctx, real| ctx.push(f64::round(real) as i32));
}
assert_eq!(result, vec![2, 3]);
sourcepub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(L) -> Either<S, R>,
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(L) -> Either<S, R>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Apply the function f
on the value in the Left
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
sourcepub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(R) -> Either<L, S>,
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(R) -> Either<L, S>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Apply the function f
on the value in the Right
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
sourcepub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Convert the inner value to an iterator.
use either::*;
let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
let mut right: Either<Vec<u32>, _> = Right(vec![]);
right.extend(left.into_iter());
assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));
sourcepub fn left_or(self, other: L) -> L
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
the result of a function call, it is recommended to use left_or_else
,
which is lazily evaluated.
Examples
let left: Either<&str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");
let right: Either<&str, &str> = Right("right");
assert_eq!(right.left_or("left"), "left");
sourcepub fn left_or_default(self) -> L where
L: Default,
pub fn left_or_default(self) -> L where
L: Default,
Return left or a default
Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.left_or_default(), "left");
let right: Either<String, u32> = Right(42);
assert_eq!(right.left_or_default(), String::default());
sourcepub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
pub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
Returns left value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.left_or_else(|_| unreachable!()), "3");
let right: Either<String, u32> = Right(3);
assert_eq!(right.left_or_else(|x| x.to_string()), "3");
sourcepub fn right_or(self, other: R) -> R
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
the result of a function call, it is recommended to use right_or_else
,
which is lazily evaluated.
Examples
let right: Either<&str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");
let left: Either<&str, &str> = Left("left");
assert_eq!(left.right_or("right"), "right");
sourcepub fn right_or_default(self) -> R where
R: Default,
pub fn right_or_default(self) -> R where
R: Default,
Return right or a default
Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.right_or_default(), u32::default());
let right: Either<String, u32> = Right(42);
assert_eq!(right.right_or_default(), 42);
sourcepub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
pub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
Returns right value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);
let right: Either<String, u32> = Right(3);
assert_eq!(right.right_or_else(|_| unreachable!()), 3);
sourcepub fn unwrap_left(self) -> L where
R: Debug,
pub fn unwrap_left(self) -> L where
R: Debug,
sourcepub fn unwrap_right(self) -> R where
L: Debug,
pub fn unwrap_right(self) -> R where
L: Debug,
sourcepub fn expect_left(self, msg: &str) -> L where
R: Debug,
pub fn expect_left(self, msg: &str) -> L where
R: Debug,
sourcepub fn expect_right(self, msg: &str) -> R where
L: Debug,
pub fn expect_right(self, msg: &str) -> R where
L: Debug,
sourcepub fn either_into<T>(self) -> T where
L: Into<T>,
R: Into<T>,
pub fn either_into<T>(self) -> T where
L: Into<T>,
R: Into<T>,
Convert the contained value into T
Examples
// Both u16 and u32 can be converted to u64.
let left: Either<u16, u32> = Left(3u16);
assert_eq!(left.either_into::<u64>(), 3u64);
let right: Either<u16, u32> = Right(7u32);
assert_eq!(right.either_into::<u64>(), 7u64);
sourceimpl<L, R> Either<Option<L>, Option<R>>
impl<L, R> Either<Option<L>, Option<R>>
sourcepub fn factor_none(self) -> Option<Either<L, R>>
pub fn factor_none(self) -> Option<Either<L, R>>
Factors out None
from an Either
of Option
.
use either::*;
let left: Either<_, Option<String>> = Left(Some(vec![0]));
assert_eq!(left.factor_none(), Some(Left(vec![0])));
let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
assert_eq!(right.factor_none(), Some(Right(String::new())));
sourceimpl<L, R, E> Either<Result<L, E>, Result<R, E>>
impl<L, R, E> Either<Result<L, E>, Result<R, E>>
sourcepub fn factor_err(self) -> Result<Either<L, R>, E>
pub fn factor_err(self) -> Result<Either<L, R>, E>
Factors out a homogenous type from an Either
of Result
.
Here, the homogeneous type is the Err
type of the Result
.
use either::*;
let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
assert_eq!(left.factor_err(), Ok(Left(vec![0])));
let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
assert_eq!(right.factor_err(), Ok(Right(String::new())));
sourceimpl<T, L, R> Either<Result<T, L>, Result<T, R>>
impl<T, L, R> Either<Result<T, L>, Result<T, R>>
sourcepub fn factor_ok(self) -> Result<T, Either<L, R>>
pub fn factor_ok(self) -> Result<T, Either<L, R>>
Factors out a homogenous type from an Either
of Result
.
Here, the homogeneous type is the Ok
type of the Result
.
use either::*;
let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
assert_eq!(left.factor_ok(), Err(Left(vec![0])));
let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
assert_eq!(right.factor_ok(), Err(Right(String::new())));
sourceimpl<T, L, R> Either<(T, L), (T, R)>
impl<T, L, R> Either<(T, L), (T, R)>
sourcepub fn factor_first(self) -> (T, Either<L, R>)
pub fn factor_first(self) -> (T, Either<L, R>)
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the first element of the pairs.
use either::*;
let left: Either<_, (u32, String)> = Left((123, vec![0]));
assert_eq!(left.factor_first().0, 123);
let right: Either<(u32, Vec<u8>), _> = Right((123, String::new()));
assert_eq!(right.factor_first().0, 123);
sourceimpl<T, L, R> Either<(L, T), (R, T)>
impl<T, L, R> Either<(L, T), (R, T)>
sourcepub fn factor_second(self) -> (Either<L, R>, T)
pub fn factor_second(self) -> (Either<L, R>, T)
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the second element of the pairs.
use either::*;
let left: Either<_, (String, u32)> = Left((vec![0], 123));
assert_eq!(left.factor_second().1, 123);
let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123));
assert_eq!(right.factor_second().1, 123);
sourceimpl<T> Either<T, T>
impl<T> Either<T, T>
sourcepub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Extract the value of an either over two equivalent types.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.into_inner(), 123);
let right: Either<u32, _> = Right(123);
assert_eq!(right.into_inner(), 123);
sourcepub fn map<F, M>(self, f: F) -> Either<M, M>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(T) -> M,
pub fn map<F, M>(self, f: F) -> Either<M, M>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
where
F: FnOnce(T) -> M,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Map f
over the contained value and return the result in the
corresponding variant.
use either::*;
let value: Either<_, i32> = Right(42);
let other = value.map(|x| x * 2);
assert_eq!(other, Right(84));
Trait Implementations
sourceimpl<L, R, Target> AsMut<[Target]> for Either<L, R> where
L: AsMut<[Target]>,
R: AsMut<[Target]>,
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
L: AsMut<[Target]>,
R: AsMut<[Target]>,
sourceimpl<L, R> AsMut<CStr> for Either<L, R> where
L: AsMut<CStr>,
R: AsMut<CStr>,
impl<L, R> AsMut<CStr> for Either<L, R> where
L: AsMut<CStr>,
R: AsMut<CStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsMut<OsStr> for Either<L, R> where
L: AsMut<OsStr>,
R: AsMut<OsStr>,
impl<L, R> AsMut<OsStr> for Either<L, R> where
L: AsMut<OsStr>,
R: AsMut<OsStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsMut<Path> for Either<L, R> where
L: AsMut<Path>,
R: AsMut<Path>,
impl<L, R> AsMut<Path> for Either<L, R> where
L: AsMut<Path>,
R: AsMut<Path>,
Requires crate feature use_std
.
sourceimpl<L, R, Target> AsRef<[Target]> for Either<L, R> where
L: AsRef<[Target]>,
R: AsRef<[Target]>,
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
L: AsRef<[Target]>,
R: AsRef<[Target]>,
sourceimpl<L, R> AsRef<CStr> for Either<L, R> where
L: AsRef<CStr>,
R: AsRef<CStr>,
impl<L, R> AsRef<CStr> for Either<L, R> where
L: AsRef<CStr>,
R: AsRef<CStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsRef<OsStr> for Either<L, R> where
L: AsRef<OsStr>,
R: AsRef<OsStr>,
impl<L, R> AsRef<OsStr> for Either<L, R> where
L: AsRef<OsStr>,
R: AsRef<OsStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsRef<Path> for Either<L, R> where
L: AsRef<Path>,
R: AsRef<Path>,
impl<L, R> AsRef<Path> for Either<L, R> where
L: AsRef<Path>,
R: AsRef<Path>,
Requires crate feature use_std
.
sourceimpl<L, R> BufRead for Either<L, R> where
L: BufRead,
R: BufRead,
impl<L, R> BufRead for Either<L, R> where
L: BufRead,
R: BufRead,
Requires crate feature "use_std"
sourcefn fill_buf(&mut self) -> Result<&[u8], Error>
fn fill_buf(&mut self) -> Result<&[u8], Error>
Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
sourcefn consume(&mut self, amt: usize)
fn consume(&mut self, amt: usize)
Tells this buffer that amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read more
sourcefn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Check if the underlying Read
has any data left to be read. Read more
1.0.0 · sourcefn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
Read all bytes into buf
until the delimiter byte
or EOF is reached. Read more
1.0.0 · sourcefn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until a newline (the 0xA
byte) is reached, and append
them to the provided buffer. You do not need to clear the buffer before
appending. Read more
sourceimpl<L, R> Clone for Either<L, R> where
L: Clone,
R: Clone,
impl<L, R> Clone for Either<L, R> where
L: Clone,
R: Clone,
sourcefn clone(&self) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
fn clone(&self) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Returns a copy of the value. Read more
sourcefn clone_from(&mut self, source: &Either<L, R>)
fn clone_from(&mut self, source: &Either<L, R>)
Performs copy-assignment from source
. Read more
sourceimpl<L, R> Deref for Either<L, R> where
L: Deref,
R: Deref<Target = <L as Deref>::Target>,
impl<L, R> Deref for Either<L, R> where
L: Deref,
R: Deref<Target = <L as Deref>::Target>,
sourcefn deref(&self) -> &<Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
fn deref(&self) -> &<Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Dereferences the value.
sourceimpl<L, R> DerefMut for Either<L, R> where
L: DerefMut,
R: DerefMut<Target = <L as Deref>::Target>,
impl<L, R> DerefMut for Either<L, R> where
L: DerefMut,
R: DerefMut<Target = <L as Deref>::Target>,
sourcefn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
fn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Mutably dereferences the value.
sourceimpl<L, R> DoubleEndedIterator for Either<L, R> where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
impl<L, R> DoubleEndedIterator for Either<L, R> where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
sourcefn next_back(&mut self) -> Option<<Either<L, R> 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
sourcefn rfold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
An iterator method that reduces the iterator’s elements to a single, final value, starting from the back. Read more
sourcefn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item> where
P: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item> where
P: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
Searches for an element of an iterator from the back that satisfies a predicate. Read more
sourcefn advance_back_by(&mut self, n: usize) -> Result<(), usize>
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)Advances the iterator from the back by n
elements. Read more
sourceimpl<L, R> Error for Either<L, R> where
L: Error,
R: Error,
impl<L, R> Error for Either<L, R> where
L: Error,
R: Error,
Either
implements Error
if both L
and R
implement it.
sourcefn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
sourcefn description(&self) -> &str
fn description(&self) -> &str
use the Display impl or to_string()
sourceimpl<L, R> ExactSizeIterator for Either<L, R> where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
impl<L, R> ExactSizeIterator for Either<L, R> where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
sourceimpl<L, R, A> Extend<A> for Either<L, R> where
L: Extend<A>,
R: Extend<A>,
impl<L, R, A> Extend<A> for Either<L, R> where
L: Extend<A>,
R: Extend<A>,
sourcefn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<A, B> Fold for Either<A, B> where
A: Fold,
B: Fold,
impl<A, B> Fold for Either<A, B> where
A: Fold,
B: Fold,
fn fold_accessibility(&mut self, n: Accessibility) -> Accessibility
fn fold_array_lit(&mut self, n: ArrayLit) -> ArrayLit
fn fold_array_pat(&mut self, n: ArrayPat) -> ArrayPat
fn fold_arrow_expr(&mut self, n: ArrowExpr) -> ArrowExpr
fn fold_assign_expr(&mut self, n: AssignExpr) -> AssignExpr
fn fold_assign_op(&mut self, n: AssignOp) -> AssignOp
fn fold_assign_pat(&mut self, n: AssignPat) -> AssignPat
fn fold_assign_pat_prop(&mut self, n: AssignPatProp) -> AssignPatProp
fn fold_assign_prop(&mut self, n: AssignProp) -> AssignProp
fn fold_await_expr(&mut self, n: AwaitExpr) -> AwaitExpr
fn fold_big_int(&mut self, n: BigInt) -> BigInt
fn fold_big_int_value(&mut self, n: BigInt) -> BigInt
fn fold_bin_expr(&mut self, n: BinExpr) -> BinExpr
fn fold_binary_op(&mut self, n: BinaryOp) -> BinaryOp
fn fold_binding_ident(&mut self, n: BindingIdent) -> BindingIdent
fn fold_block_stmt(&mut self, n: BlockStmt) -> BlockStmt
fn fold_block_stmt_or_expr(&mut self, n: BlockStmtOrExpr) -> BlockStmtOrExpr
fn fold_bool(&mut self, n: Bool) -> Bool
fn fold_break_stmt(&mut self, n: BreakStmt) -> BreakStmt
fn fold_call_expr(&mut self, n: CallExpr) -> CallExpr
fn fold_callee(&mut self, n: Callee) -> Callee
fn fold_catch_clause(&mut self, n: CatchClause) -> CatchClause
fn fold_class(&mut self, n: Class) -> Class
fn fold_class_decl(&mut self, n: ClassDecl) -> ClassDecl
fn fold_class_expr(&mut self, n: ClassExpr) -> ClassExpr
fn fold_class_member(&mut self, n: ClassMember) -> ClassMember
fn fold_class_members(
&mut self,
n: Vec<ClassMember, Global>
) -> Vec<ClassMember, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_class_method(&mut self, n: ClassMethod) -> ClassMethod
fn fold_class_prop(&mut self, n: ClassProp) -> ClassProp
fn fold_computed_prop_name(&mut self, n: ComputedPropName) -> ComputedPropName
fn fold_cond_expr(&mut self, n: CondExpr) -> CondExpr
fn fold_constructor(&mut self, n: Constructor) -> Constructor
fn fold_continue_stmt(&mut self, n: ContinueStmt) -> ContinueStmt
fn fold_debugger_stmt(&mut self, n: DebuggerStmt) -> DebuggerStmt
fn fold_decl(&mut self, n: Decl) -> Decl
fn fold_decorator(&mut self, n: Decorator) -> Decorator
fn fold_decorators(
&mut self,
n: Vec<Decorator, Global>
) -> Vec<Decorator, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_default_decl(&mut self, n: DefaultDecl) -> DefaultDecl
fn fold_do_while_stmt(&mut self, n: DoWhileStmt) -> DoWhileStmt
fn fold_empty_stmt(&mut self, n: EmptyStmt) -> EmptyStmt
fn fold_export_all(&mut self, n: ExportAll) -> ExportAll
fn fold_export_decl(&mut self, n: ExportDecl) -> ExportDecl
fn fold_export_default_decl(
&mut self,
n: ExportDefaultDecl
) -> ExportDefaultDecl
fn fold_export_default_expr(
&mut self,
n: ExportDefaultExpr
) -> ExportDefaultExpr
fn fold_export_default_specifier(
&mut self,
n: ExportDefaultSpecifier
) -> ExportDefaultSpecifier
fn fold_export_named_specifier(
&mut self,
n: ExportNamedSpecifier
) -> ExportNamedSpecifier
fn fold_export_namespace_specifier(
&mut self,
n: ExportNamespaceSpecifier
) -> ExportNamespaceSpecifier
fn fold_export_specifier(&mut self, n: ExportSpecifier) -> ExportSpecifier
fn fold_export_specifiers(
&mut self,
n: Vec<ExportSpecifier, Global>
) -> Vec<ExportSpecifier, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_expr(&mut self, n: Expr) -> Expr
fn fold_expr_or_spread(&mut self, n: ExprOrSpread) -> ExprOrSpread
fn fold_expr_or_spreads(
&mut self,
n: Vec<ExprOrSpread, Global>
) -> Vec<ExprOrSpread, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_expr_stmt(&mut self, n: ExprStmt) -> ExprStmt
fn fold_exprs(
&mut self,
n: Vec<Box<Expr, Global>, Global>
) -> Vec<Box<Expr, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_f_64(&mut self, n: f64) -> f64
fn fold_fn_decl(&mut self, n: FnDecl) -> FnDecl
fn fold_fn_expr(&mut self, n: FnExpr) -> FnExpr
fn fold_for_in_stmt(&mut self, n: ForInStmt) -> ForInStmt
fn fold_for_of_stmt(&mut self, n: ForOfStmt) -> ForOfStmt
fn fold_for_stmt(&mut self, n: ForStmt) -> ForStmt
fn fold_function(&mut self, n: Function) -> Function
fn fold_getter_prop(&mut self, n: GetterProp) -> GetterProp
fn fold_ident(&mut self, n: Ident) -> Ident
fn fold_if_stmt(&mut self, n: IfStmt) -> IfStmt
fn fold_import(&mut self, n: Import) -> Import
fn fold_import_decl(&mut self, n: ImportDecl) -> ImportDecl
fn fold_import_default_specifier(
&mut self,
n: ImportDefaultSpecifier
) -> ImportDefaultSpecifier
fn fold_import_named_specifier(
&mut self,
n: ImportNamedSpecifier
) -> ImportNamedSpecifier
fn fold_import_specifier(&mut self, n: ImportSpecifier) -> ImportSpecifier
fn fold_import_specifiers(
&mut self,
n: Vec<ImportSpecifier, Global>
) -> Vec<ImportSpecifier, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_import_star_as_specifier(
&mut self,
n: ImportStarAsSpecifier
) -> ImportStarAsSpecifier
fn fold_invalid(&mut self, n: Invalid) -> Invalid
fn fold_js_word(&mut self, n: Atom<JsWordStaticSet>) -> Atom<JsWordStaticSet>
fn fold_jsx_attr(&mut self, n: JSXAttr) -> JSXAttr
fn fold_jsx_attr_name(&mut self, n: JSXAttrName) -> JSXAttrName
fn fold_jsx_attr_or_spread(&mut self, n: JSXAttrOrSpread) -> JSXAttrOrSpread
fn fold_jsx_attr_or_spreads(
&mut self,
n: Vec<JSXAttrOrSpread, Global>
) -> Vec<JSXAttrOrSpread, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_jsx_attr_value(&mut self, n: JSXAttrValue) -> JSXAttrValue
fn fold_jsx_closing_element(
&mut self,
n: JSXClosingElement
) -> JSXClosingElement
fn fold_jsx_closing_fragment(
&mut self,
n: JSXClosingFragment
) -> JSXClosingFragment
fn fold_jsx_element(&mut self, n: JSXElement) -> JSXElement
fn fold_jsx_element_child(&mut self, n: JSXElementChild) -> JSXElementChild
fn fold_jsx_element_children(
&mut self,
n: Vec<JSXElementChild, Global>
) -> Vec<JSXElementChild, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_jsx_element_name(&mut self, n: JSXElementName) -> JSXElementName
fn fold_jsx_empty_expr(&mut self, n: JSXEmptyExpr) -> JSXEmptyExpr
fn fold_jsx_expr(&mut self, n: JSXExpr) -> JSXExpr
fn fold_jsx_expr_container(&mut self, n: JSXExprContainer) -> JSXExprContainer
fn fold_jsx_fragment(&mut self, n: JSXFragment) -> JSXFragment
fn fold_jsx_member_expr(&mut self, n: JSXMemberExpr) -> JSXMemberExpr
fn fold_jsx_namespaced_name(
&mut self,
n: JSXNamespacedName
) -> JSXNamespacedName
fn fold_jsx_object(&mut self, n: JSXObject) -> JSXObject
fn fold_jsx_opening_element(
&mut self,
n: JSXOpeningElement
) -> JSXOpeningElement
fn fold_jsx_opening_fragment(
&mut self,
n: JSXOpeningFragment
) -> JSXOpeningFragment
fn fold_jsx_spread_child(&mut self, n: JSXSpreadChild) -> JSXSpreadChild
fn fold_jsx_text(&mut self, n: JSXText) -> JSXText
fn fold_key_value_pat_prop(&mut self, n: KeyValuePatProp) -> KeyValuePatProp
fn fold_key_value_prop(&mut self, n: KeyValueProp) -> KeyValueProp
fn fold_labeled_stmt(&mut self, n: LabeledStmt) -> LabeledStmt
fn fold_lit(&mut self, n: Lit) -> Lit
fn fold_member_expr(&mut self, n: MemberExpr) -> MemberExpr
fn fold_member_prop(&mut self, n: MemberProp) -> MemberProp
fn fold_meta_prop_expr(&mut self, n: MetaPropExpr) -> MetaPropExpr
fn fold_meta_prop_kind(&mut self, n: MetaPropKind) -> MetaPropKind
fn fold_method_kind(&mut self, n: MethodKind) -> MethodKind
fn fold_method_prop(&mut self, n: MethodProp) -> MethodProp
fn fold_module(&mut self, n: Module) -> Module
fn fold_module_decl(&mut self, n: ModuleDecl) -> ModuleDecl
fn fold_module_export_name(&mut self, n: ModuleExportName) -> ModuleExportName
fn fold_module_item(&mut self, n: ModuleItem) -> ModuleItem
fn fold_module_items(
&mut self,
n: Vec<ModuleItem, Global>
) -> Vec<ModuleItem, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_named_export(&mut self, n: NamedExport) -> NamedExport
fn fold_new_expr(&mut self, n: NewExpr) -> NewExpr
fn fold_null(&mut self, n: Null) -> Null
fn fold_number(&mut self, n: Number) -> Number
fn fold_object_lit(&mut self, n: ObjectLit) -> ObjectLit
fn fold_object_pat(&mut self, n: ObjectPat) -> ObjectPat
fn fold_object_pat_prop(&mut self, n: ObjectPatProp) -> ObjectPatProp
fn fold_object_pat_props(
&mut self,
n: Vec<ObjectPatProp, Global>
) -> Vec<ObjectPatProp, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_opt_accessibility(
&mut self,
n: Option<Accessibility>
) -> Option<Accessibility>
fn fold_opt_block_stmt(&mut self, n: Option<BlockStmt>) -> Option<BlockStmt>
fn fold_opt_call(&mut self, n: OptCall) -> OptCall
fn fold_opt_catch_clause(
&mut self,
n: Option<CatchClause>
) -> Option<CatchClause>
fn fold_opt_chain_base(&mut self, n: OptChainBase) -> OptChainBase
fn fold_opt_chain_expr(&mut self, n: OptChainExpr) -> OptChainExpr
fn fold_opt_expr(
&mut self,
n: Option<Box<Expr, Global>>
) -> Option<Box<Expr, Global>>
fn fold_opt_expr_or_spread(
&mut self,
n: Option<ExprOrSpread>
) -> Option<ExprOrSpread>
fn fold_opt_expr_or_spreads(
&mut self,
n: Option<Vec<ExprOrSpread, Global>>
) -> Option<Vec<ExprOrSpread, Global>>
fn fold_opt_ident(&mut self, n: Option<Ident>) -> Option<Ident>
fn fold_opt_js_word(
&mut self,
n: Option<Atom<JsWordStaticSet>>
) -> Option<Atom<JsWordStaticSet>>
fn fold_opt_jsx_attr_value(
&mut self,
n: Option<JSXAttrValue>
) -> Option<JSXAttrValue>
fn fold_opt_jsx_closing_element(
&mut self,
n: Option<JSXClosingElement>
) -> Option<JSXClosingElement>
fn fold_opt_module_export_name(
&mut self,
n: Option<ModuleExportName>
) -> Option<ModuleExportName>
fn fold_opt_object_lit(&mut self, n: Option<ObjectLit>) -> Option<ObjectLit>
fn fold_opt_pat(&mut self, n: Option<Pat>) -> Option<Pat>
fn fold_opt_span(&mut self, n: Option<Span>) -> Option<Span>
fn fold_opt_stmt(
&mut self,
n: Option<Box<Stmt, Global>>
) -> Option<Box<Stmt, Global>>
fn fold_opt_str(&mut self, n: Option<Str>) -> Option<Str>
fn fold_opt_true_plus_minus(
&mut self,
n: Option<TruePlusMinus>
) -> Option<TruePlusMinus>
fn fold_opt_ts_entity_name(
&mut self,
n: Option<TsEntityName>
) -> Option<TsEntityName>
fn fold_opt_ts_namespace_body(
&mut self,
n: Option<TsNamespaceBody>
) -> Option<TsNamespaceBody>
fn fold_opt_ts_type(
&mut self,
n: Option<Box<TsType, Global>>
) -> Option<Box<TsType, Global>>
fn fold_opt_ts_type_ann(&mut self, n: Option<TsTypeAnn>) -> Option<TsTypeAnn>
fn fold_opt_ts_type_param_decl(
&mut self,
n: Option<TsTypeParamDecl>
) -> Option<TsTypeParamDecl>
fn fold_opt_ts_type_param_instantiation(
&mut self,
n: Option<TsTypeParamInstantiation>
) -> Option<TsTypeParamInstantiation>
fn fold_opt_var_decl_or_expr(
&mut self,
n: Option<VarDeclOrExpr>
) -> Option<VarDeclOrExpr>
fn fold_opt_vec_expr_or_spreads(
&mut self,
n: Vec<Option<ExprOrSpread>, Global>
) -> Vec<Option<ExprOrSpread>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_opt_vec_pats(
&mut self,
n: Vec<Option<Pat>, Global>
) -> Vec<Option<Pat>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_param(&mut self, n: Param) -> Param
fn fold_param_or_ts_param_prop(
&mut self,
n: ParamOrTsParamProp
) -> ParamOrTsParamProp
fn fold_param_or_ts_param_props(
&mut self,
n: Vec<ParamOrTsParamProp, Global>
) -> Vec<ParamOrTsParamProp, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_params(&mut self, n: Vec<Param, Global>) -> Vec<Param, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_paren_expr(&mut self, n: ParenExpr) -> ParenExpr
fn fold_pat(&mut self, n: Pat) -> Pat
fn fold_pat_or_expr(&mut self, n: PatOrExpr) -> PatOrExpr
fn fold_pats(&mut self, n: Vec<Pat, Global>) -> Vec<Pat, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_private_method(&mut self, n: PrivateMethod) -> PrivateMethod
fn fold_private_name(&mut self, n: PrivateName) -> PrivateName
fn fold_private_prop(&mut self, n: PrivateProp) -> PrivateProp
fn fold_program(&mut self, n: Program) -> Program
fn fold_prop(&mut self, n: Prop) -> Prop
fn fold_prop_name(&mut self, n: PropName) -> PropName
fn fold_prop_or_spread(&mut self, n: PropOrSpread) -> PropOrSpread
fn fold_prop_or_spreads(
&mut self,
n: Vec<PropOrSpread, Global>
) -> Vec<PropOrSpread, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_regex(&mut self, n: Regex) -> Regex
fn fold_rest_pat(&mut self, n: RestPat) -> RestPat
fn fold_return_stmt(&mut self, n: ReturnStmt) -> ReturnStmt
fn fold_script(&mut self, n: Script) -> Script
fn fold_seq_expr(&mut self, n: SeqExpr) -> SeqExpr
fn fold_setter_prop(&mut self, n: SetterProp) -> SetterProp
fn fold_span(&mut self, n: Span) -> Span
fn fold_spread_element(&mut self, n: SpreadElement) -> SpreadElement
fn fold_static_block(&mut self, n: StaticBlock) -> StaticBlock
fn fold_stmt(&mut self, n: Stmt) -> Stmt
fn fold_stmts(&mut self, n: Vec<Stmt, Global>) -> Vec<Stmt, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_str(&mut self, n: Str) -> Str
fn fold_super(&mut self, n: Super) -> Super
fn fold_super_prop(&mut self, n: SuperProp) -> SuperProp
fn fold_super_prop_expr(&mut self, n: SuperPropExpr) -> SuperPropExpr
fn fold_switch_case(&mut self, n: SwitchCase) -> SwitchCase
fn fold_switch_cases(
&mut self,
n: Vec<SwitchCase, Global>
) -> Vec<SwitchCase, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_switch_stmt(&mut self, n: SwitchStmt) -> SwitchStmt
fn fold_tagged_tpl(&mut self, n: TaggedTpl) -> TaggedTpl
fn fold_this_expr(&mut self, n: ThisExpr) -> ThisExpr
fn fold_throw_stmt(&mut self, n: ThrowStmt) -> ThrowStmt
fn fold_tpl(&mut self, n: Tpl) -> Tpl
fn fold_tpl_element(&mut self, n: TplElement) -> TplElement
fn fold_tpl_elements(
&mut self,
n: Vec<TplElement, Global>
) -> Vec<TplElement, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_true_plus_minus(&mut self, n: TruePlusMinus) -> TruePlusMinus
fn fold_try_stmt(&mut self, n: TryStmt) -> TryStmt
fn fold_ts_array_type(&mut self, n: TsArrayType) -> TsArrayType
fn fold_ts_as_expr(&mut self, n: TsAsExpr) -> TsAsExpr
fn fold_ts_call_signature_decl(
&mut self,
n: TsCallSignatureDecl
) -> TsCallSignatureDecl
fn fold_ts_conditional_type(
&mut self,
n: TsConditionalType
) -> TsConditionalType
fn fold_ts_const_assertion(&mut self, n: TsConstAssertion) -> TsConstAssertion
fn fold_ts_construct_signature_decl(
&mut self,
n: TsConstructSignatureDecl
) -> TsConstructSignatureDecl
fn fold_ts_constructor_type(
&mut self,
n: TsConstructorType
) -> TsConstructorType
fn fold_ts_entity_name(&mut self, n: TsEntityName) -> TsEntityName
fn fold_ts_enum_decl(&mut self, n: TsEnumDecl) -> TsEnumDecl
fn fold_ts_enum_member(&mut self, n: TsEnumMember) -> TsEnumMember
fn fold_ts_enum_member_id(&mut self, n: TsEnumMemberId) -> TsEnumMemberId
fn fold_ts_enum_members(
&mut self,
n: Vec<TsEnumMember, Global>
) -> Vec<TsEnumMember, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_export_assignment(
&mut self,
n: TsExportAssignment
) -> TsExportAssignment
fn fold_ts_expr_with_type_args(
&mut self,
n: TsExprWithTypeArgs
) -> TsExprWithTypeArgs
fn fold_ts_expr_with_type_args_vec(
&mut self,
n: Vec<TsExprWithTypeArgs, Global>
) -> Vec<TsExprWithTypeArgs, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_external_module_ref(
&mut self,
n: TsExternalModuleRef
) -> TsExternalModuleRef
fn fold_ts_fn_or_constructor_type(
&mut self,
n: TsFnOrConstructorType
) -> TsFnOrConstructorType
fn fold_ts_fn_param(&mut self, n: TsFnParam) -> TsFnParam
fn fold_ts_fn_params(
&mut self,
n: Vec<TsFnParam, Global>
) -> Vec<TsFnParam, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_fn_type(&mut self, n: TsFnType) -> TsFnType
fn fold_ts_getter_signature(
&mut self,
n: TsGetterSignature
) -> TsGetterSignature
fn fold_ts_import_equals_decl(
&mut self,
n: TsImportEqualsDecl
) -> TsImportEqualsDecl
fn fold_ts_import_type(&mut self, n: TsImportType) -> TsImportType
fn fold_ts_index_signature(&mut self, n: TsIndexSignature) -> TsIndexSignature
fn fold_ts_indexed_access_type(
&mut self,
n: TsIndexedAccessType
) -> TsIndexedAccessType
fn fold_ts_infer_type(&mut self, n: TsInferType) -> TsInferType
fn fold_ts_instantiation(&mut self, n: TsInstantiation) -> TsInstantiation
fn fold_ts_interface_body(&mut self, n: TsInterfaceBody) -> TsInterfaceBody
fn fold_ts_interface_decl(&mut self, n: TsInterfaceDecl) -> TsInterfaceDecl
fn fold_ts_intersection_type(
&mut self,
n: TsIntersectionType
) -> TsIntersectionType
fn fold_ts_keyword_type(&mut self, n: TsKeywordType) -> TsKeywordType
fn fold_ts_keyword_type_kind(
&mut self,
n: TsKeywordTypeKind
) -> TsKeywordTypeKind
fn fold_ts_lit(&mut self, n: TsLit) -> TsLit
fn fold_ts_lit_type(&mut self, n: TsLitType) -> TsLitType
fn fold_ts_mapped_type(&mut self, n: TsMappedType) -> TsMappedType
fn fold_ts_method_signature(
&mut self,
n: TsMethodSignature
) -> TsMethodSignature
fn fold_ts_module_block(&mut self, n: TsModuleBlock) -> TsModuleBlock
fn fold_ts_module_decl(&mut self, n: TsModuleDecl) -> TsModuleDecl
fn fold_ts_module_name(&mut self, n: TsModuleName) -> TsModuleName
fn fold_ts_module_ref(&mut self, n: TsModuleRef) -> TsModuleRef
fn fold_ts_namespace_body(&mut self, n: TsNamespaceBody) -> TsNamespaceBody
fn fold_ts_namespace_decl(&mut self, n: TsNamespaceDecl) -> TsNamespaceDecl
fn fold_ts_namespace_export_decl(
&mut self,
n: TsNamespaceExportDecl
) -> TsNamespaceExportDecl
fn fold_ts_non_null_expr(&mut self, n: TsNonNullExpr) -> TsNonNullExpr
fn fold_ts_optional_type(&mut self, n: TsOptionalType) -> TsOptionalType
fn fold_ts_param_prop(&mut self, n: TsParamProp) -> TsParamProp
fn fold_ts_param_prop_param(&mut self, n: TsParamPropParam) -> TsParamPropParam
fn fold_ts_parenthesized_type(
&mut self,
n: TsParenthesizedType
) -> TsParenthesizedType
fn fold_ts_property_signature(
&mut self,
n: TsPropertySignature
) -> TsPropertySignature
fn fold_ts_qualified_name(&mut self, n: TsQualifiedName) -> TsQualifiedName
fn fold_ts_rest_type(&mut self, n: TsRestType) -> TsRestType
fn fold_ts_setter_signature(
&mut self,
n: TsSetterSignature
) -> TsSetterSignature
fn fold_ts_this_type(&mut self, n: TsThisType) -> TsThisType
fn fold_ts_this_type_or_ident(
&mut self,
n: TsThisTypeOrIdent
) -> TsThisTypeOrIdent
fn fold_ts_tpl_lit_type(&mut self, n: TsTplLitType) -> TsTplLitType
fn fold_ts_tuple_element(&mut self, n: TsTupleElement) -> TsTupleElement
fn fold_ts_tuple_elements(
&mut self,
n: Vec<TsTupleElement, Global>
) -> Vec<TsTupleElement, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_tuple_type(&mut self, n: TsTupleType) -> TsTupleType
fn fold_ts_type(&mut self, n: TsType) -> TsType
fn fold_ts_type_alias_decl(&mut self, n: TsTypeAliasDecl) -> TsTypeAliasDecl
fn fold_ts_type_ann(&mut self, n: TsTypeAnn) -> TsTypeAnn
fn fold_ts_type_assertion(&mut self, n: TsTypeAssertion) -> TsTypeAssertion
fn fold_ts_type_element(&mut self, n: TsTypeElement) -> TsTypeElement
fn fold_ts_type_elements(
&mut self,
n: Vec<TsTypeElement, Global>
) -> Vec<TsTypeElement, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_type_lit(&mut self, n: TsTypeLit) -> TsTypeLit
fn fold_ts_type_operator(&mut self, n: TsTypeOperator) -> TsTypeOperator
fn fold_ts_type_operator_op(&mut self, n: TsTypeOperatorOp) -> TsTypeOperatorOp
fn fold_ts_type_param(&mut self, n: TsTypeParam) -> TsTypeParam
fn fold_ts_type_param_decl(&mut self, n: TsTypeParamDecl) -> TsTypeParamDecl
fn fold_ts_type_param_instantiation(
&mut self,
n: TsTypeParamInstantiation
) -> TsTypeParamInstantiation
fn fold_ts_type_params(
&mut self,
n: Vec<TsTypeParam, Global>
) -> Vec<TsTypeParam, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_type_predicate(&mut self, n: TsTypePredicate) -> TsTypePredicate
fn fold_ts_type_query(&mut self, n: TsTypeQuery) -> TsTypeQuery
fn fold_ts_type_query_expr(&mut self, n: TsTypeQueryExpr) -> TsTypeQueryExpr
fn fold_ts_type_ref(&mut self, n: TsTypeRef) -> TsTypeRef
fn fold_ts_types(
&mut self,
n: Vec<Box<TsType, Global>, Global>
) -> Vec<Box<TsType, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_ts_union_or_intersection_type(
&mut self,
n: TsUnionOrIntersectionType
) -> TsUnionOrIntersectionType
fn fold_ts_union_type(&mut self, n: TsUnionType) -> TsUnionType
fn fold_unary_expr(&mut self, n: UnaryExpr) -> UnaryExpr
fn fold_unary_op(&mut self, n: UnaryOp) -> UnaryOp
fn fold_update_expr(&mut self, n: UpdateExpr) -> UpdateExpr
fn fold_update_op(&mut self, n: UpdateOp) -> UpdateOp
fn fold_var_decl(&mut self, n: VarDecl) -> VarDecl
fn fold_var_decl_kind(&mut self, n: VarDeclKind) -> VarDeclKind
fn fold_var_decl_or_expr(&mut self, n: VarDeclOrExpr) -> VarDeclOrExpr
fn fold_var_decl_or_pat(&mut self, n: VarDeclOrPat) -> VarDeclOrPat
fn fold_var_declarator(&mut self, n: VarDeclarator) -> VarDeclarator
fn fold_var_declarators(
&mut self,
n: Vec<VarDeclarator, Global>
) -> Vec<VarDeclarator, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
fn fold_while_stmt(&mut self, n: WhileStmt) -> WhileStmt
fn fold_with_stmt(&mut self, n: WithStmt) -> WithStmt
fn fold_yield_expr(&mut self, n: YieldExpr) -> YieldExpr
sourceimpl<L, R> From<Result<R, L>> for Either<L, R>
impl<L, R> From<Result<R, L>> for Either<L, R>
Convert from Result
to Either
with Ok => Right
and Err => Left
.
sourcefn from(r: Result<R, L>) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
fn from(r: Result<R, L>) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
L: Write,
R: Write, impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Converts to this type from the input type.
sourceimpl<L, R> Into<Result<R, L>> for Either<L, R>
impl<L, R> Into<Result<R, L>> for Either<L, R>
Convert from Either
to Result
with Right => Ok
and Left => Err
.
sourceimpl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>,
impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>,
Either<L, R>
is an iterator if both L
and R
are iterators.
sourcefn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
Advances the iterator and returns the next value. Read more
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the iterator. Read more
sourcefn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
Folds every element into an accumulator by applying an operation, returning the final result. Read more
sourcefn for_each<F>(self, f: F) where
F: FnMut(<Either<L, R> as Iterator>::Item),
fn for_each<F>(self, f: F) where
F: FnMut(<Either<L, R> as Iterator>::Item),
Calls a closure on each element of an iterator. Read more
sourcefn count(self) -> usize
fn count(self) -> usize
Consumes the iterator, counting the number of iterations and returning it. Read more
sourcefn last(self) -> Option<<Either<L, R> as Iterator>::Item>
fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
Consumes the iterator, returning the last element. Read more
sourcefn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
Returns the n
th element of the iterator. Read more
sourcefn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
Transforms an iterator into a collection. Read more
sourcefn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<<Either<L, R> as Iterator>::Item>,
F: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<<Either<L, R> as Iterator>::Item>,
F: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
Consumes an iterator, creating two collections from it. Read more
sourcefn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
Tests if every element of the iterator matches a predicate. Read more
sourcefn any<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
Tests if any element of the iterator matches a predicate. Read more
sourcefn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item> where
P: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item> where
P: for<'_> FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
Searches for an element of an iterator that satisfies a predicate. Read more
sourcefn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(<Either<L, R> as Iterator>::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(<Either<L, R> as Iterator>::Item) -> Option<B>,
Applies function to the elements of iterator and returns the first non-none result. Read more
sourcefn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
Searches for an element in an iterator, returning its index. Read more
sourcefn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
iter_next_chunk
)Advances the iterator and returns an array containing the next N
values. Read more
sourcefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)Advances the iterator by n
elements. Read more
1.28.0 · sourcefn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
1.0.0 · sourcefn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both in sequence. Read more
1.0.0 · sourcefn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
‘Zips up’ two iterators into a single iterator of pairs. Read more
sourcefn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
iter_intersperse
)Creates a new iterator which places a copy of separator
between adjacent
items of the original iterator. Read more
sourcefn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
iter_intersperse
)Creates a new iterator which places an item generated by separator
between adjacent items of the original iterator. Read more
1.0.0 · sourcefn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
Takes a closure and creates an iterator which calls that closure on each element. Read more
1.0.0 · sourcefn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
Creates an iterator which uses a closure to determine if an element should be yielded. Read more
1.0.0 · sourcefn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both filters and maps. Read more
1.0.0 · sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
Creates an iterator which gives the current iteration count as well as the next value. Read more
1.0.0 · sourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: for<'_> FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate. Read more
1.57.0 · sourcefn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both yields elements based on a predicate and maps. Read more
1.0.0 · sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
Creates an iterator that skips the first n
elements. Read more
1.0.0 · sourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
Creates an iterator that yields the first n
elements, or fewer
if the underlying iterator ends sooner. Read more
1.0.0 · sourcefn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: for<'_> FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: for<'_> FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
Creates an iterator that works like map, but flattens nested structure. Read more
1.29.0 · sourcefn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
Creates an iterator that flattens nested structure. Read more
1.0.0 · sourcefn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: for<'_> FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: for<'_> FnMut(&Self::Item),
Does something with each element of an iterator, passing the value on. Read more
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
Borrows an iterator, rather than consuming it. Read more
sourcefn try_collect<B>(
&mut self
) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType where
B: FromIterator<<Self::Item as Try>::Output>,
Self::Item: Try,
<Self::Item as Try>::Residual: Residual<B>,
fn try_collect<B>(
&mut self
) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType where
B: FromIterator<<Self::Item as Try>::Output>,
Self::Item: Try,
<Self::Item as Try>::Residual: Residual<B>,
iterator_try_collect
)Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered. Read more
sourcefn collect_into<E>(self, collection: &mut E) -> &mut E where
E: Extend<Self::Item>,
fn collect_into<E>(self, collection: &mut E) -> &mut E where
E: Extend<Self::Item>,
iter_collect_into
)Collects all the items from an iterator into a collection. Read more
sourcefn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
T: 'a,
Self: DoubleEndedIterator<Item = &'a mut T>,
P: for<'_> FnMut(&T) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
T: 'a,
Self: DoubleEndedIterator<Item = &'a mut T>,
P: for<'_> FnMut(&T) -> bool,
iter_partition_in_place
)Reorders the elements of this iterator in-place according to the given predicate,
such that all those that return true
precede all those that return false
.
Returns the number of true
elements found. Read more
sourcefn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return true
precede all those that return false
. Read more
1.27.0 · sourcefn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more
sourcefn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType where
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType where
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. Read more
sourcefn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType where
F: for<'_> FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType where
F: for<'_> FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)Applies function to the elements of iterator and returns the first true result or the first error. Read more
1.0.0 · sourcefn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
Searches for an element in an iterator from the right, returning its index. Read more
1.0.0 · sourcefn max(self) -> Option<Self::Item> where
Self::Item: Ord,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
Returns the maximum element of an iterator. Read more
1.0.0 · sourcefn min(self) -> Option<Self::Item> where
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
Returns the minimum element of an iterator. Read more
1.6.0 · sourcefn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: for<'_> FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: for<'_> FnMut(&Self::Item) -> B,
Returns the element that gives the maximum value from the specified function. Read more
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the maximum value with respect to the specified comparison function. Read more
1.6.0 · sourcefn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: for<'_> FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: for<'_> FnMut(&Self::Item) -> B,
Returns the element that gives the minimum value from the specified function. Read more
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the minimum value with respect to the specified comparison function. Read more
1.0.0 · sourcefn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
Reverses an iterator’s direction. Read more
1.0.0 · sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
Converts an iterator of pairs into a pair of containers. Read more
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self> where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self> where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
Creates an iterator which copies all of its elements. Read more
1.0.0 · sourcefn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
1.0.0 · sourcefn cycle(self) -> Cycle<Self> where
Self: Clone,
fn cycle(self) -> Cycle<Self> where
Self: Clone,
Repeats an iterator endlessly. Read more
1.11.0 · sourcefn sum<S>(self) -> S where
S: Sum<Self::Item>,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
Sums the elements of an iterator. Read more
1.11.0 · sourcefn product<P>(self) -> P where
P: Product<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
Iterates over the entire iterator, multiplying all the elements Read more
1.5.0 · sourcefn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Lexicographically compares the elements of this Iterator
with those
of another. Read more
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
1.5.0 · sourcefn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Lexicographically compares the elements of this Iterator
with those
of another. Read more
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
1.5.0 · sourcefn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · sourcefn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0 · sourcefn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically
less than those of another. Read more
1.5.0 · sourcefn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically
less or equal to those of another. Read more
1.5.0 · sourcefn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically
greater than those of another. Read more
1.5.0 · sourcefn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically
greater than or equal to those of another. Read more
sourcefn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
is_sorted
)Checks if the elements of this iterator are sorted. Read more
sourcefn is_sorted_by<F>(self, compare: F) -> bool where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: for<'_, '_> FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)Checks if the elements of this iterator are sorted using the given comparator function. Read more
sourcefn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
)Checks if the elements of this iterator are sorted using the given key extraction function. Read more
sourceimpl<L, R> Ord for Either<L, R> where
L: Ord,
R: Ord,
impl<L, R> Ord for Either<L, R> where
L: Ord,
R: Ord,
sourceimpl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
L: PartialOrd<L>,
R: PartialOrd<R>,
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
L: PartialOrd<L>,
R: PartialOrd<R>,
sourcefn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
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 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
Either<L, R>
implements Read
if both L
and R
do.
Requires crate feature "use_std"
sourcefn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
sourcefn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
Read all bytes until EOF in this source, placing them into buf
. Read more
1.36.0 · sourcefn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
Like read
, except that it reads into a slice of buffers. Read more
sourcefn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)Determines if this Read
er has an efficient read_vectored
implementation. Read more
1.0.0 · sourcefn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until EOF in this source, appending them to buf
. Read more
1.6.0 · sourcefn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
Read the exact number of bytes required to fill buf
. Read more
sourcefn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
read_buf
)Pull some bytes from this source into the specified buffer. Read more
sourcefn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
read_buf
)Read the exact number of bytes required to fill buf
. Read more
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
Creates a “by reference” adaptor for this instance of Read
. Read more
sourceimpl<L, R> Seek for Either<L, R> where
L: Seek,
R: Seek,
impl<L, R> Seek for Either<L, R> where
L: Seek,
R: Seek,
Either<L, R>
implements Seek
if both L
and R
do.
Requires crate feature "use_std"
sourcefn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
Seek to an offset, in bytes, in a stream. Read more
1.55.0 · sourcefn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), Error>
Rewind to the beginning of a stream. Read more
impl<A, B> Visit for Either<A, B> where
A: Visit,
B: Visit,
impl<A, B> Visit for Either<A, B> where
A: Visit,
B: Visit,
fn visit_accessibility(&mut self, n: &Accessibility)
fn visit_array_lit(&mut self, n: &ArrayLit)
fn visit_array_pat(&mut self, n: &ArrayPat)
fn visit_arrow_expr(&mut self, n: &ArrowExpr)
fn visit_assign_expr(&mut self, n: &AssignExpr)
fn visit_assign_op(&mut self, n: &AssignOp)
fn visit_assign_pat(&mut self, n: &AssignPat)
fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
fn visit_assign_prop(&mut self, n: &AssignProp)
fn visit_await_expr(&mut self, n: &AwaitExpr)
fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int_value(&mut self, n: &BigInt)
fn visit_bin_expr(&mut self, n: &BinExpr)
fn visit_binary_op(&mut self, n: &BinaryOp)
fn visit_binding_ident(&mut self, n: &BindingIdent)
fn visit_block_stmt(&mut self, n: &BlockStmt)
fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
fn visit_bool(&mut self, n: &Bool)
fn visit_break_stmt(&mut self, n: &BreakStmt)
fn visit_call_expr(&mut self, n: &CallExpr)
fn visit_callee(&mut self, n: &Callee)
fn visit_catch_clause(&mut self, n: &CatchClause)
fn visit_class(&mut self, n: &Class)
fn visit_class_decl(&mut self, n: &ClassDecl)
fn visit_class_expr(&mut self, n: &ClassExpr)
fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_members(&mut self, n: &[ClassMember])
fn visit_class_method(&mut self, n: &ClassMethod)
fn visit_class_prop(&mut self, n: &ClassProp)
fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
fn visit_cond_expr(&mut self, n: &CondExpr)
fn visit_constructor(&mut self, n: &Constructor)
fn visit_continue_stmt(&mut self, n: &ContinueStmt)
fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
fn visit_decl(&mut self, n: &Decl)
fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorators(&mut self, n: &[Decorator])
fn visit_default_decl(&mut self, n: &DefaultDecl)
fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
fn visit_empty_stmt(&mut self, n: &EmptyStmt)
fn visit_export_all(&mut self, n: &ExportAll)
fn visit_export_decl(&mut self, n: &ExportDecl)
fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])
fn visit_expr(&mut self, n: &Expr)
fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])
fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_exprs(&mut self, n: &[Box<Expr, Global>])
fn visit_f_64(&mut self, n: &f64)
fn visit_fn_decl(&mut self, n: &FnDecl)
fn visit_fn_expr(&mut self, n: &FnExpr)
fn visit_for_in_stmt(&mut self, n: &ForInStmt)
fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
fn visit_for_stmt(&mut self, n: &ForStmt)
fn visit_function(&mut self, n: &Function)
fn visit_getter_prop(&mut self, n: &GetterProp)
fn visit_ident(&mut self, n: &Ident)
fn visit_if_stmt(&mut self, n: &IfStmt)
fn visit_import(&mut self, n: &Import)
fn visit_import_decl(&mut self, n: &ImportDecl)
fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])
fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
fn visit_invalid(&mut self, n: &Invalid)
fn visit_js_word(&mut self, n: &Atom<JsWordStaticSet>)
fn visit_jsx_attr(&mut self, n: &JSXAttr)
fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])
fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
fn visit_jsx_element(&mut self, n: &JSXElement)
fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])
fn visit_jsx_element_name(&mut self, n: &JSXElementName)
fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
fn visit_jsx_expr(&mut self, n: &JSXExpr)
fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
fn visit_jsx_fragment(&mut self, n: &JSXFragment)
fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
fn visit_jsx_object(&mut self, n: &JSXObject)
fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
fn visit_jsx_text(&mut self, n: &JSXText)
fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
fn visit_key_value_prop(&mut self, n: &KeyValueProp)
fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
fn visit_lit(&mut self, n: &Lit)
fn visit_member_expr(&mut self, n: &MemberExpr)
fn visit_member_prop(&mut self, n: &MemberProp)
fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
fn visit_method_kind(&mut self, n: &MethodKind)
fn visit_method_prop(&mut self, n: &MethodProp)
fn visit_module(&mut self, n: &Module)
fn visit_module_decl(&mut self, n: &ModuleDecl)
fn visit_module_export_name(&mut self, n: &ModuleExportName)
fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_items(&mut self, n: &[ModuleItem])
fn visit_named_export(&mut self, n: &NamedExport)
fn visit_new_expr(&mut self, n: &NewExpr)
fn visit_null(&mut self, n: &Null)
fn visit_number(&mut self, n: &Number)
fn visit_object_lit(&mut self, n: &ObjectLit)
fn visit_object_pat(&mut self, n: &ObjectPat)
fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])
fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)
fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)
fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)
fn visit_opt_chain_base(&mut self, n: &OptChainBase)
fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
fn visit_opt_expr(&mut self, n: Option<&Box<Expr, Global>>)
fn visit_opt_expr_or_spread(&mut self, n: Option<&ExprOrSpread>)
fn visit_opt_expr_or_spreads(&mut self, n: Option<&[ExprOrSpread]>)
fn visit_opt_ident(&mut self, n: Option<&Ident>)
fn visit_opt_js_word(&mut self, n: Option<&Atom<JsWordStaticSet>>)
fn visit_opt_jsx_attr_value(&mut self, n: Option<&JSXAttrValue>)
fn visit_opt_jsx_closing_element(&mut self, n: Option<&JSXClosingElement>)
fn visit_opt_module_export_name(&mut self, n: Option<&ModuleExportName>)
fn visit_opt_object_lit(&mut self, n: Option<&ObjectLit>)
fn visit_opt_pat(&mut self, n: Option<&Pat>)
fn visit_opt_span(&mut self, n: Option<&Span>)
fn visit_opt_stmt(&mut self, n: Option<&Box<Stmt, Global>>)
fn visit_opt_str(&mut self, n: Option<&Str>)
fn visit_opt_true_plus_minus(&mut self, n: Option<&TruePlusMinus>)
fn visit_opt_ts_entity_name(&mut self, n: Option<&TsEntityName>)
fn visit_opt_ts_namespace_body(&mut self, n: Option<&TsNamespaceBody>)
fn visit_opt_ts_type(&mut self, n: Option<&Box<TsType, Global>>)
fn visit_opt_ts_type_ann(&mut self, n: Option<&TsTypeAnn>)
fn visit_opt_ts_type_param_decl(&mut self, n: Option<&TsTypeParamDecl>)
fn visit_opt_ts_type_param_instantiation(
&mut self,
n: Option<&TsTypeParamInstantiation>
)
fn visit_opt_var_decl_or_expr(&mut self, n: Option<&VarDeclOrExpr>)
fn visit_opt_vec_expr_or_spreads(&mut self, n: &[Option<ExprOrSpread>])
fn visit_opt_vec_pats(&mut self, n: &[Option<Pat>])
fn visit_param(&mut self, n: &Param)
fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_props(&mut self, n: &[ParamOrTsParamProp])
fn visit_params(&mut self, n: &[Param])
fn visit_paren_expr(&mut self, n: &ParenExpr)
fn visit_pat(&mut self, n: &Pat)
fn visit_pat_or_expr(&mut self, n: &PatOrExpr)
fn visit_pats(&mut self, n: &[Pat])
fn visit_private_method(&mut self, n: &PrivateMethod)
fn visit_private_name(&mut self, n: &PrivateName)
fn visit_private_prop(&mut self, n: &PrivateProp)
fn visit_program(&mut self, n: &Program)
fn visit_prop(&mut self, n: &Prop)
fn visit_prop_name(&mut self, n: &PropName)
fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])
fn visit_regex(&mut self, n: &Regex)
fn visit_rest_pat(&mut self, n: &RestPat)
fn visit_return_stmt(&mut self, n: &ReturnStmt)
fn visit_script(&mut self, n: &Script)
fn visit_seq_expr(&mut self, n: &SeqExpr)
fn visit_setter_prop(&mut self, n: &SetterProp)
fn visit_span(&mut self, n: &Span)
fn visit_spread_element(&mut self, n: &SpreadElement)
fn visit_static_block(&mut self, n: &StaticBlock)
fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmts(&mut self, n: &[Stmt])
fn visit_str(&mut self, n: &Str)
fn visit_super(&mut self, n: &Super)
fn visit_super_prop(&mut self, n: &SuperProp)
fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_cases(&mut self, n: &[SwitchCase])
fn visit_switch_stmt(&mut self, n: &SwitchStmt)
fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
fn visit_this_expr(&mut self, n: &ThisExpr)
fn visit_throw_stmt(&mut self, n: &ThrowStmt)
fn visit_tpl(&mut self, n: &Tpl)
fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_elements(&mut self, n: &[TplElement])
fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
fn visit_try_stmt(&mut self, n: &TryStmt)
fn visit_ts_array_type(&mut self, n: &TsArrayType)
fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
fn visit_ts_entity_name(&mut self, n: &TsEntityName)
fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])
fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])
fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_params(&mut self, n: &[TsFnParam])
fn visit_ts_fn_type(&mut self, n: &TsFnType)
fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
fn visit_ts_import_type(&mut self, n: &TsImportType)
fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
fn visit_ts_infer_type(&mut self, n: &TsInferType)
fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
fn visit_ts_lit(&mut self, n: &TsLit)
fn visit_ts_lit_type(&mut self, n: &TsLitType)
fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
fn visit_ts_module_name(&mut self, n: &TsModuleName)
fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
fn visit_ts_param_prop(&mut self, n: &TsParamProp)
fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
fn visit_ts_rest_type(&mut self, n: &TsRestType)
fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
fn visit_ts_this_type(&mut self, n: &TsThisType)
fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])
fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
fn visit_ts_type(&mut self, n: &TsType)
fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])
fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
fn visit_ts_type_param(&mut self, n: &TsTypeParam)
fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_params(&mut self, n: &[TsTypeParam])
fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_types(&mut self, n: &[Box<TsType, Global>])
fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
fn visit_ts_union_type(&mut self, n: &TsUnionType)
fn visit_unary_expr(&mut self, n: &UnaryExpr)
fn visit_unary_op(&mut self, n: &UnaryOp)
fn visit_update_expr(&mut self, n: &UpdateExpr)
fn visit_update_op(&mut self, n: &UpdateOp)
fn visit_var_decl(&mut self, n: &VarDecl)
fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
fn visit_var_decl_or_pat(&mut self, n: &VarDeclOrPat)
fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarators(&mut self, n: &[VarDeclarator])
fn visit_while_stmt(&mut self, n: &WhileStmt)
fn visit_with_stmt(&mut self, n: &WithStmt)
fn visit_yield_expr(&mut self, n: &YieldExpr)
impl<A, B> VisitAll for Either<A, B> where
A: VisitAll,
B: VisitAll,
impl<A, B> VisitAll for Either<A, B> where
A: VisitAll,
B: VisitAll,
fn visit_accessibility(&mut self, n: &Accessibility)
fn visit_array_lit(&mut self, n: &ArrayLit)
fn visit_array_pat(&mut self, n: &ArrayPat)
fn visit_arrow_expr(&mut self, n: &ArrowExpr)
fn visit_assign_expr(&mut self, n: &AssignExpr)
fn visit_assign_op(&mut self, n: &AssignOp)
fn visit_assign_pat(&mut self, n: &AssignPat)
fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
fn visit_assign_prop(&mut self, n: &AssignProp)
fn visit_await_expr(&mut self, n: &AwaitExpr)
fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int_value(&mut self, n: &BigInt)
fn visit_bin_expr(&mut self, n: &BinExpr)
fn visit_binary_op(&mut self, n: &BinaryOp)
fn visit_binding_ident(&mut self, n: &BindingIdent)
fn visit_block_stmt(&mut self, n: &BlockStmt)
fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
fn visit_bool(&mut self, n: &Bool)
fn visit_break_stmt(&mut self, n: &BreakStmt)
fn visit_call_expr(&mut self, n: &CallExpr)
fn visit_callee(&mut self, n: &Callee)
fn visit_catch_clause(&mut self, n: &CatchClause)
fn visit_class(&mut self, n: &Class)
fn visit_class_decl(&mut self, n: &ClassDecl)
fn visit_class_expr(&mut self, n: &ClassExpr)
fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_members(&mut self, n: &[ClassMember])
fn visit_class_method(&mut self, n: &ClassMethod)
fn visit_class_prop(&mut self, n: &ClassProp)
fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
fn visit_cond_expr(&mut self, n: &CondExpr)
fn visit_constructor(&mut self, n: &Constructor)
fn visit_continue_stmt(&mut self, n: &ContinueStmt)
fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
fn visit_decl(&mut self, n: &Decl)
fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorators(&mut self, n: &[Decorator])
fn visit_default_decl(&mut self, n: &DefaultDecl)
fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
fn visit_empty_stmt(&mut self, n: &EmptyStmt)
fn visit_export_all(&mut self, n: &ExportAll)
fn visit_export_decl(&mut self, n: &ExportDecl)
fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])
fn visit_expr(&mut self, n: &Expr)
fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])
fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_exprs(&mut self, n: &[Box<Expr, Global>])
fn visit_f_64(&mut self, n: &f64)
fn visit_fn_decl(&mut self, n: &FnDecl)
fn visit_fn_expr(&mut self, n: &FnExpr)
fn visit_for_in_stmt(&mut self, n: &ForInStmt)
fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
fn visit_for_stmt(&mut self, n: &ForStmt)
fn visit_function(&mut self, n: &Function)
fn visit_getter_prop(&mut self, n: &GetterProp)
fn visit_ident(&mut self, n: &Ident)
fn visit_if_stmt(&mut self, n: &IfStmt)
fn visit_import(&mut self, n: &Import)
fn visit_import_decl(&mut self, n: &ImportDecl)
fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])
fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
fn visit_invalid(&mut self, n: &Invalid)
fn visit_js_word(&mut self, n: &Atom<JsWordStaticSet>)
fn visit_jsx_attr(&mut self, n: &JSXAttr)
fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])
fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
fn visit_jsx_element(&mut self, n: &JSXElement)
fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])
fn visit_jsx_element_name(&mut self, n: &JSXElementName)
fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
fn visit_jsx_expr(&mut self, n: &JSXExpr)
fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
fn visit_jsx_fragment(&mut self, n: &JSXFragment)
fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
fn visit_jsx_object(&mut self, n: &JSXObject)
fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
fn visit_jsx_text(&mut self, n: &JSXText)
fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
fn visit_key_value_prop(&mut self, n: &KeyValueProp)
fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
fn visit_lit(&mut self, n: &Lit)
fn visit_member_expr(&mut self, n: &MemberExpr)
fn visit_member_prop(&mut self, n: &MemberProp)
fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
fn visit_method_kind(&mut self, n: &MethodKind)
fn visit_method_prop(&mut self, n: &MethodProp)
fn visit_module(&mut self, n: &Module)
fn visit_module_decl(&mut self, n: &ModuleDecl)
fn visit_module_export_name(&mut self, n: &ModuleExportName)
fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_items(&mut self, n: &[ModuleItem])
fn visit_named_export(&mut self, n: &NamedExport)
fn visit_new_expr(&mut self, n: &NewExpr)
fn visit_null(&mut self, n: &Null)
fn visit_number(&mut self, n: &Number)
fn visit_object_lit(&mut self, n: &ObjectLit)
fn visit_object_pat(&mut self, n: &ObjectPat)
fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])
fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)
fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)
fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)
fn visit_opt_chain_base(&mut self, n: &OptChainBase)
fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
fn visit_opt_expr(&mut self, n: Option<&Box<Expr, Global>>)
fn visit_opt_expr_or_spread(&mut self, n: Option<&ExprOrSpread>)
fn visit_opt_expr_or_spreads(&mut self, n: Option<&[ExprOrSpread]>)
fn visit_opt_ident(&mut self, n: Option<&Ident>)
fn visit_opt_js_word(&mut self, n: Option<&Atom<JsWordStaticSet>>)
fn visit_opt_jsx_attr_value(&mut self, n: Option<&JSXAttrValue>)
fn visit_opt_jsx_closing_element(&mut self, n: Option<&JSXClosingElement>)
fn visit_opt_module_export_name(&mut self, n: Option<&ModuleExportName>)
fn visit_opt_object_lit(&mut self, n: Option<&ObjectLit>)
fn visit_opt_pat(&mut self, n: Option<&Pat>)
fn visit_opt_span(&mut self, n: Option<&Span>)
fn visit_opt_stmt(&mut self, n: Option<&Box<Stmt, Global>>)
fn visit_opt_str(&mut self, n: Option<&Str>)
fn visit_opt_true_plus_minus(&mut self, n: Option<&TruePlusMinus>)
fn visit_opt_ts_entity_name(&mut self, n: Option<&TsEntityName>)
fn visit_opt_ts_namespace_body(&mut self, n: Option<&TsNamespaceBody>)
fn visit_opt_ts_type(&mut self, n: Option<&Box<TsType, Global>>)
fn visit_opt_ts_type_ann(&mut self, n: Option<&TsTypeAnn>)
fn visit_opt_ts_type_param_decl(&mut self, n: Option<&TsTypeParamDecl>)
fn visit_opt_ts_type_param_instantiation(
&mut self,
n: Option<&TsTypeParamInstantiation>
)
fn visit_opt_var_decl_or_expr(&mut self, n: Option<&VarDeclOrExpr>)
fn visit_opt_vec_expr_or_spreads(&mut self, n: &[Option<ExprOrSpread>])
fn visit_opt_vec_pats(&mut self, n: &[Option<Pat>])
fn visit_param(&mut self, n: &Param)
fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_props(&mut self, n: &[ParamOrTsParamProp])
fn visit_params(&mut self, n: &[Param])
fn visit_paren_expr(&mut self, n: &ParenExpr)
fn visit_pat(&mut self, n: &Pat)
fn visit_pat_or_expr(&mut self, n: &PatOrExpr)
fn visit_pats(&mut self, n: &[Pat])
fn visit_private_method(&mut self, n: &PrivateMethod)
fn visit_private_name(&mut self, n: &PrivateName)
fn visit_private_prop(&mut self, n: &PrivateProp)
fn visit_program(&mut self, n: &Program)
fn visit_prop(&mut self, n: &Prop)
fn visit_prop_name(&mut self, n: &PropName)
fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])
fn visit_regex(&mut self, n: &Regex)
fn visit_rest_pat(&mut self, n: &RestPat)
fn visit_return_stmt(&mut self, n: &ReturnStmt)
fn visit_script(&mut self, n: &Script)
fn visit_seq_expr(&mut self, n: &SeqExpr)
fn visit_setter_prop(&mut self, n: &SetterProp)
fn visit_span(&mut self, n: &Span)
fn visit_spread_element(&mut self, n: &SpreadElement)
fn visit_static_block(&mut self, n: &StaticBlock)
fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmts(&mut self, n: &[Stmt])
fn visit_str(&mut self, n: &Str)
fn visit_super(&mut self, n: &Super)
fn visit_super_prop(&mut self, n: &SuperProp)
fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_cases(&mut self, n: &[SwitchCase])
fn visit_switch_stmt(&mut self, n: &SwitchStmt)
fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
fn visit_this_expr(&mut self, n: &ThisExpr)
fn visit_throw_stmt(&mut self, n: &ThrowStmt)
fn visit_tpl(&mut self, n: &Tpl)
fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_elements(&mut self, n: &[TplElement])
fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
fn visit_try_stmt(&mut self, n: &TryStmt)
fn visit_ts_array_type(&mut self, n: &TsArrayType)
fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
fn visit_ts_entity_name(&mut self, n: &TsEntityName)
fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])
fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])
fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_params(&mut self, n: &[TsFnParam])
fn visit_ts_fn_type(&mut self, n: &TsFnType)
fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
fn visit_ts_import_type(&mut self, n: &TsImportType)
fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
fn visit_ts_infer_type(&mut self, n: &TsInferType)
fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
fn visit_ts_lit(&mut self, n: &TsLit)
fn visit_ts_lit_type(&mut self, n: &TsLitType)
fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
fn visit_ts_module_name(&mut self, n: &TsModuleName)
fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
fn visit_ts_param_prop(&mut self, n: &TsParamProp)
fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
fn visit_ts_rest_type(&mut self, n: &TsRestType)
fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
fn visit_ts_this_type(&mut self, n: &TsThisType)
fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])
fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
fn visit_ts_type(&mut self, n: &TsType)
fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])
fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
fn visit_ts_type_param(&mut self, n: &TsTypeParam)
fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_params(&mut self, n: &[TsTypeParam])
fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_types(&mut self, n: &[Box<TsType, Global>])
fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
fn visit_ts_union_type(&mut self, n: &TsUnionType)
fn visit_unary_expr(&mut self, n: &UnaryExpr)
fn visit_unary_op(&mut self, n: &UnaryOp)
fn visit_update_expr(&mut self, n: &UpdateExpr)
fn visit_update_op(&mut self, n: &UpdateOp)
fn visit_var_decl(&mut self, n: &VarDecl)
fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
fn visit_var_decl_or_pat(&mut self, n: &VarDeclOrPat)
fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarators(&mut self, n: &[VarDeclarator])
fn visit_while_stmt(&mut self, n: &WhileStmt)
fn visit_with_stmt(&mut self, n: &WithStmt)
fn visit_yield_expr(&mut self, n: &YieldExpr)
impl<A, B> VisitMut for Either<A, B> where
A: VisitMut,
B: VisitMut,
impl<A, B> VisitMut for Either<A, B> where
A: VisitMut,
B: VisitMut,
fn visit_mut_accessibility(&mut self, n: &mut Accessibility)
fn visit_mut_array_lit(&mut self, n: &mut ArrayLit)
fn visit_mut_array_pat(&mut self, n: &mut ArrayPat)
fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr)
fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr)
fn visit_mut_assign_op(&mut self, n: &mut AssignOp)
fn visit_mut_assign_pat(&mut self, n: &mut AssignPat)
fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp)
fn visit_mut_assign_prop(&mut self, n: &mut AssignProp)
fn visit_mut_await_expr(&mut self, n: &mut AwaitExpr)
fn visit_mut_big_int(&mut self, n: &mut BigInt)
fn visit_mut_big_int_value(&mut self, n: &mut BigInt)
fn visit_mut_bin_expr(&mut self, n: &mut BinExpr)
fn visit_mut_binary_op(&mut self, n: &mut BinaryOp)
fn visit_mut_binding_ident(&mut self, n: &mut BindingIdent)
fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt)
fn visit_mut_block_stmt_or_expr(&mut self, n: &mut BlockStmtOrExpr)
fn visit_mut_bool(&mut self, n: &mut Bool)
fn visit_mut_break_stmt(&mut self, n: &mut BreakStmt)
fn visit_mut_call_expr(&mut self, n: &mut CallExpr)
fn visit_mut_callee(&mut self, n: &mut Callee)
fn visit_mut_catch_clause(&mut self, n: &mut CatchClause)
fn visit_mut_class(&mut self, n: &mut Class)
fn visit_mut_class_decl(&mut self, n: &mut ClassDecl)
fn visit_mut_class_expr(&mut self, n: &mut ClassExpr)
fn visit_mut_class_member(&mut self, n: &mut ClassMember)
fn visit_mut_class_members(&mut self, n: &mut Vec<ClassMember, Global>)
fn visit_mut_class_method(&mut self, n: &mut ClassMethod)
fn visit_mut_class_prop(&mut self, n: &mut ClassProp)
fn visit_mut_computed_prop_name(&mut self, n: &mut ComputedPropName)
fn visit_mut_cond_expr(&mut self, n: &mut CondExpr)
fn visit_mut_constructor(&mut self, n: &mut Constructor)
fn visit_mut_continue_stmt(&mut self, n: &mut ContinueStmt)
fn visit_mut_debugger_stmt(&mut self, n: &mut DebuggerStmt)
fn visit_mut_decl(&mut self, n: &mut Decl)
fn visit_mut_decorator(&mut self, n: &mut Decorator)
fn visit_mut_decorators(&mut self, n: &mut Vec<Decorator, Global>)
fn visit_mut_default_decl(&mut self, n: &mut DefaultDecl)
fn visit_mut_do_while_stmt(&mut self, n: &mut DoWhileStmt)
fn visit_mut_empty_stmt(&mut self, n: &mut EmptyStmt)
fn visit_mut_export_all(&mut self, n: &mut ExportAll)
fn visit_mut_export_decl(&mut self, n: &mut ExportDecl)
fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl)
fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr)
fn visit_mut_export_default_specifier(&mut self, n: &mut ExportDefaultSpecifier)
fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier)
fn visit_mut_export_namespace_specifier(
&mut self,
n: &mut ExportNamespaceSpecifier
)
fn visit_mut_export_specifier(&mut self, n: &mut ExportSpecifier)
fn visit_mut_export_specifiers(&mut self, n: &mut Vec<ExportSpecifier, Global>)
fn visit_mut_expr(&mut self, n: &mut Expr)
fn visit_mut_expr_or_spread(&mut self, n: &mut ExprOrSpread)
fn visit_mut_expr_or_spreads(&mut self, n: &mut Vec<ExprOrSpread, Global>)
fn visit_mut_expr_stmt(&mut self, n: &mut ExprStmt)
fn visit_mut_exprs(&mut self, n: &mut Vec<Box<Expr, Global>, Global>)
fn visit_mut_f_64(&mut self, n: &mut f64)
fn visit_mut_fn_decl(&mut self, n: &mut FnDecl)
fn visit_mut_fn_expr(&mut self, n: &mut FnExpr)
fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt)
fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt)
fn visit_mut_for_stmt(&mut self, n: &mut ForStmt)
fn visit_mut_function(&mut self, n: &mut Function)
fn visit_mut_getter_prop(&mut self, n: &mut GetterProp)
fn visit_mut_ident(&mut self, n: &mut Ident)
fn visit_mut_if_stmt(&mut self, n: &mut IfStmt)
fn visit_mut_import(&mut self, n: &mut Import)
fn visit_mut_import_decl(&mut self, n: &mut ImportDecl)
fn visit_mut_import_default_specifier(&mut self, n: &mut ImportDefaultSpecifier)
fn visit_mut_import_named_specifier(&mut self, n: &mut ImportNamedSpecifier)
fn visit_mut_import_specifier(&mut self, n: &mut ImportSpecifier)
fn visit_mut_import_specifiers(&mut self, n: &mut Vec<ImportSpecifier, Global>)
fn visit_mut_import_star_as_specifier(&mut self, n: &mut ImportStarAsSpecifier)
fn visit_mut_invalid(&mut self, n: &mut Invalid)
fn visit_mut_js_word(&mut self, n: &mut Atom<JsWordStaticSet>)
fn visit_mut_jsx_attr(&mut self, n: &mut JSXAttr)
fn visit_mut_jsx_attr_name(&mut self, n: &mut JSXAttrName)
fn visit_mut_jsx_attr_or_spread(&mut self, n: &mut JSXAttrOrSpread)
fn visit_mut_jsx_attr_or_spreads(
&mut self,
n: &mut Vec<JSXAttrOrSpread, Global>
)
fn visit_mut_jsx_attr_value(&mut self, n: &mut JSXAttrValue)
fn visit_mut_jsx_closing_element(&mut self, n: &mut JSXClosingElement)
fn visit_mut_jsx_closing_fragment(&mut self, n: &mut JSXClosingFragment)
fn visit_mut_jsx_element(&mut self, n: &mut JSXElement)
fn visit_mut_jsx_element_child(&mut self, n: &mut JSXElementChild)
fn visit_mut_jsx_element_children(
&mut self,
n: &mut Vec<JSXElementChild, Global>
)
fn visit_mut_jsx_element_name(&mut self, n: &mut JSXElementName)
fn visit_mut_jsx_empty_expr(&mut self, n: &mut JSXEmptyExpr)
fn visit_mut_jsx_expr(&mut self, n: &mut JSXExpr)
fn visit_mut_jsx_expr_container(&mut self, n: &mut JSXExprContainer)
fn visit_mut_jsx_fragment(&mut self, n: &mut JSXFragment)
fn visit_mut_jsx_member_expr(&mut self, n: &mut JSXMemberExpr)
fn visit_mut_jsx_namespaced_name(&mut self, n: &mut JSXNamespacedName)
fn visit_mut_jsx_object(&mut self, n: &mut JSXObject)
fn visit_mut_jsx_opening_element(&mut self, n: &mut JSXOpeningElement)
fn visit_mut_jsx_opening_fragment(&mut self, n: &mut JSXOpeningFragment)
fn visit_mut_jsx_spread_child(&mut self, n: &mut JSXSpreadChild)
fn visit_mut_jsx_text(&mut self, n: &mut JSXText)
fn visit_mut_key_value_pat_prop(&mut self, n: &mut KeyValuePatProp)
fn visit_mut_key_value_prop(&mut self, n: &mut KeyValueProp)
fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt)
fn visit_mut_lit(&mut self, n: &mut Lit)
fn visit_mut_member_expr(&mut self, n: &mut MemberExpr)
fn visit_mut_member_prop(&mut self, n: &mut MemberProp)
fn visit_mut_meta_prop_expr(&mut self, n: &mut MetaPropExpr)
fn visit_mut_meta_prop_kind(&mut self, n: &mut MetaPropKind)
fn visit_mut_method_kind(&mut self, n: &mut MethodKind)
fn visit_mut_method_prop(&mut self, n: &mut MethodProp)
fn visit_mut_module(&mut self, n: &mut Module)
fn visit_mut_module_decl(&mut self, n: &mut ModuleDecl)
fn visit_mut_module_export_name(&mut self, n: &mut ModuleExportName)
fn visit_mut_module_item(&mut self, n: &mut ModuleItem)
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem, Global>)
fn visit_mut_named_export(&mut self, n: &mut NamedExport)
fn visit_mut_new_expr(&mut self, n: &mut NewExpr)
fn visit_mut_null(&mut self, n: &mut Null)
fn visit_mut_number(&mut self, n: &mut Number)
fn visit_mut_object_lit(&mut self, n: &mut ObjectLit)
fn visit_mut_object_pat(&mut self, n: &mut ObjectPat)
fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp)
fn visit_mut_object_pat_props(&mut self, n: &mut Vec<ObjectPatProp, Global>)
fn visit_mut_opt_accessibility(&mut self, n: &mut Option<Accessibility>)
fn visit_mut_opt_block_stmt(&mut self, n: &mut Option<BlockStmt>)
fn visit_mut_opt_call(&mut self, n: &mut OptCall)
fn visit_mut_opt_catch_clause(&mut self, n: &mut Option<CatchClause>)
fn visit_mut_opt_chain_base(&mut self, n: &mut OptChainBase)
fn visit_mut_opt_chain_expr(&mut self, n: &mut OptChainExpr)
fn visit_mut_opt_expr(&mut self, n: &mut Option<Box<Expr, Global>>)
fn visit_mut_opt_expr_or_spread(&mut self, n: &mut Option<ExprOrSpread>)
fn visit_mut_opt_expr_or_spreads(
&mut self,
n: &mut Option<Vec<ExprOrSpread, Global>>
)
fn visit_mut_opt_ident(&mut self, n: &mut Option<Ident>)
fn visit_mut_opt_js_word(&mut self, n: &mut Option<Atom<JsWordStaticSet>>)
fn visit_mut_opt_jsx_attr_value(&mut self, n: &mut Option<JSXAttrValue>)
fn visit_mut_opt_jsx_closing_element(
&mut self,
n: &mut Option<JSXClosingElement>
)
fn visit_mut_opt_module_export_name(&mut self, n: &mut Option<ModuleExportName>)
fn visit_mut_opt_object_lit(&mut self, n: &mut Option<ObjectLit>)
fn visit_mut_opt_pat(&mut self, n: &mut Option<Pat>)
fn visit_mut_opt_span(&mut self, n: &mut Option<Span>)
fn visit_mut_opt_stmt(&mut self, n: &mut Option<Box<Stmt, Global>>)
fn visit_mut_opt_str(&mut self, n: &mut Option<Str>)
fn visit_mut_opt_true_plus_minus(&mut self, n: &mut Option<TruePlusMinus>)
fn visit_mut_opt_ts_entity_name(&mut self, n: &mut Option<TsEntityName>)
fn visit_mut_opt_ts_namespace_body(&mut self, n: &mut Option<TsNamespaceBody>)
fn visit_mut_opt_ts_type(&mut self, n: &mut Option<Box<TsType, Global>>)
fn visit_mut_opt_ts_type_ann(&mut self, n: &mut Option<TsTypeAnn>)
fn visit_mut_opt_ts_type_param_decl(&mut self, n: &mut Option<TsTypeParamDecl>)
fn visit_mut_opt_ts_type_param_instantiation(
&mut self,
n: &mut Option<TsTypeParamInstantiation>
)
fn visit_mut_opt_var_decl_or_expr(&mut self, n: &mut Option<VarDeclOrExpr>)
fn visit_mut_opt_vec_expr_or_spreads(
&mut self,
n: &mut Vec<Option<ExprOrSpread>, Global>
)
fn visit_mut_opt_vec_pats(&mut self, n: &mut Vec<Option<Pat>, Global>)
fn visit_mut_param(&mut self, n: &mut Param)
fn visit_mut_param_or_ts_param_prop(&mut self, n: &mut ParamOrTsParamProp)
fn visit_mut_param_or_ts_param_props(
&mut self,
n: &mut Vec<ParamOrTsParamProp, Global>
)
fn visit_mut_params(&mut self, n: &mut Vec<Param, Global>)
fn visit_mut_paren_expr(&mut self, n: &mut ParenExpr)
fn visit_mut_pat(&mut self, n: &mut Pat)
fn visit_mut_pat_or_expr(&mut self, n: &mut PatOrExpr)
fn visit_mut_pats(&mut self, n: &mut Vec<Pat, Global>)
fn visit_mut_private_method(&mut self, n: &mut PrivateMethod)
fn visit_mut_private_name(&mut self, n: &mut PrivateName)
fn visit_mut_private_prop(&mut self, n: &mut PrivateProp)
fn visit_mut_program(&mut self, n: &mut Program)
fn visit_mut_prop(&mut self, n: &mut Prop)
fn visit_mut_prop_name(&mut self, n: &mut PropName)
fn visit_mut_prop_or_spread(&mut self, n: &mut PropOrSpread)
fn visit_mut_prop_or_spreads(&mut self, n: &mut Vec<PropOrSpread, Global>)
fn visit_mut_regex(&mut self, n: &mut Regex)
fn visit_mut_rest_pat(&mut self, n: &mut RestPat)
fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt)
fn visit_mut_script(&mut self, n: &mut Script)
fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr)
fn visit_mut_setter_prop(&mut self, n: &mut SetterProp)
fn visit_mut_span(&mut self, n: &mut Span)
fn visit_mut_spread_element(&mut self, n: &mut SpreadElement)
fn visit_mut_static_block(&mut self, n: &mut StaticBlock)
fn visit_mut_stmt(&mut self, n: &mut Stmt)
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt, Global>)
fn visit_mut_str(&mut self, n: &mut Str)
fn visit_mut_super(&mut self, n: &mut Super)
fn visit_mut_super_prop(&mut self, n: &mut SuperProp)
fn visit_mut_super_prop_expr(&mut self, n: &mut SuperPropExpr)
fn visit_mut_switch_case(&mut self, n: &mut SwitchCase)
fn visit_mut_switch_cases(&mut self, n: &mut Vec<SwitchCase, Global>)
fn visit_mut_switch_stmt(&mut self, n: &mut SwitchStmt)
fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl)
fn visit_mut_this_expr(&mut self, n: &mut ThisExpr)
fn visit_mut_throw_stmt(&mut self, n: &mut ThrowStmt)
fn visit_mut_tpl(&mut self, n: &mut Tpl)
fn visit_mut_tpl_element(&mut self, n: &mut TplElement)
fn visit_mut_tpl_elements(&mut self, n: &mut Vec<TplElement, Global>)
fn visit_mut_true_plus_minus(&mut self, n: &mut TruePlusMinus)
fn visit_mut_try_stmt(&mut self, n: &mut TryStmt)
fn visit_mut_ts_array_type(&mut self, n: &mut TsArrayType)
fn visit_mut_ts_as_expr(&mut self, n: &mut TsAsExpr)
fn visit_mut_ts_call_signature_decl(&mut self, n: &mut TsCallSignatureDecl)
fn visit_mut_ts_conditional_type(&mut self, n: &mut TsConditionalType)
fn visit_mut_ts_const_assertion(&mut self, n: &mut TsConstAssertion)
fn visit_mut_ts_construct_signature_decl(
&mut self,
n: &mut TsConstructSignatureDecl
)
fn visit_mut_ts_constructor_type(&mut self, n: &mut TsConstructorType)
fn visit_mut_ts_entity_name(&mut self, n: &mut TsEntityName)
fn visit_mut_ts_enum_decl(&mut self, n: &mut TsEnumDecl)
fn visit_mut_ts_enum_member(&mut self, n: &mut TsEnumMember)
fn visit_mut_ts_enum_member_id(&mut self, n: &mut TsEnumMemberId)
fn visit_mut_ts_enum_members(&mut self, n: &mut Vec<TsEnumMember, Global>)
fn visit_mut_ts_export_assignment(&mut self, n: &mut TsExportAssignment)
fn visit_mut_ts_expr_with_type_args(&mut self, n: &mut TsExprWithTypeArgs)
fn visit_mut_ts_expr_with_type_args_vec(
&mut self,
n: &mut Vec<TsExprWithTypeArgs, Global>
)
fn visit_mut_ts_external_module_ref(&mut self, n: &mut TsExternalModuleRef)
fn visit_mut_ts_fn_or_constructor_type(&mut self, n: &mut TsFnOrConstructorType)
fn visit_mut_ts_fn_param(&mut self, n: &mut TsFnParam)
fn visit_mut_ts_fn_params(&mut self, n: &mut Vec<TsFnParam, Global>)
fn visit_mut_ts_fn_type(&mut self, n: &mut TsFnType)
fn visit_mut_ts_getter_signature(&mut self, n: &mut TsGetterSignature)
fn visit_mut_ts_import_equals_decl(&mut self, n: &mut TsImportEqualsDecl)
fn visit_mut_ts_import_type(&mut self, n: &mut TsImportType)
fn visit_mut_ts_index_signature(&mut self, n: &mut TsIndexSignature)
fn visit_mut_ts_indexed_access_type(&mut self, n: &mut TsIndexedAccessType)
fn visit_mut_ts_infer_type(&mut self, n: &mut TsInferType)
fn visit_mut_ts_instantiation(&mut self, n: &mut TsInstantiation)
fn visit_mut_ts_interface_body(&mut self, n: &mut TsInterfaceBody)
fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl)
fn visit_mut_ts_intersection_type(&mut self, n: &mut TsIntersectionType)
fn visit_mut_ts_keyword_type(&mut self, n: &mut TsKeywordType)
fn visit_mut_ts_keyword_type_kind(&mut self, n: &mut TsKeywordTypeKind)
fn visit_mut_ts_lit(&mut self, n: &mut TsLit)
fn visit_mut_ts_lit_type(&mut self, n: &mut TsLitType)
fn visit_mut_ts_mapped_type(&mut self, n: &mut TsMappedType)
fn visit_mut_ts_method_signature(&mut self, n: &mut TsMethodSignature)
fn visit_mut_ts_module_block(&mut self, n: &mut TsModuleBlock)
fn visit_mut_ts_module_decl(&mut self, n: &mut TsModuleDecl)
fn visit_mut_ts_module_name(&mut self, n: &mut TsModuleName)
fn visit_mut_ts_module_ref(&mut self, n: &mut TsModuleRef)
fn visit_mut_ts_namespace_body(&mut self, n: &mut TsNamespaceBody)
fn visit_mut_ts_namespace_decl(&mut self, n: &mut TsNamespaceDecl)
fn visit_mut_ts_namespace_export_decl(&mut self, n: &mut TsNamespaceExportDecl)
fn visit_mut_ts_non_null_expr(&mut self, n: &mut TsNonNullExpr)
fn visit_mut_ts_optional_type(&mut self, n: &mut TsOptionalType)
fn visit_mut_ts_param_prop(&mut self, n: &mut TsParamProp)
fn visit_mut_ts_param_prop_param(&mut self, n: &mut TsParamPropParam)
fn visit_mut_ts_parenthesized_type(&mut self, n: &mut TsParenthesizedType)
fn visit_mut_ts_property_signature(&mut self, n: &mut TsPropertySignature)
fn visit_mut_ts_qualified_name(&mut self, n: &mut TsQualifiedName)
fn visit_mut_ts_rest_type(&mut self, n: &mut TsRestType)
fn visit_mut_ts_setter_signature(&mut self, n: &mut TsSetterSignature)
fn visit_mut_ts_this_type(&mut self, n: &mut TsThisType)
fn visit_mut_ts_this_type_or_ident(&mut self, n: &mut TsThisTypeOrIdent)
fn visit_mut_ts_tpl_lit_type(&mut self, n: &mut TsTplLitType)
fn visit_mut_ts_tuple_element(&mut self, n: &mut TsTupleElement)
fn visit_mut_ts_tuple_elements(&mut self, n: &mut Vec<TsTupleElement, Global>)
fn visit_mut_ts_tuple_type(&mut self, n: &mut TsTupleType)
fn visit_mut_ts_type(&mut self, n: &mut TsType)
fn visit_mut_ts_type_alias_decl(&mut self, n: &mut TsTypeAliasDecl)
fn visit_mut_ts_type_ann(&mut self, n: &mut TsTypeAnn)
fn visit_mut_ts_type_assertion(&mut self, n: &mut TsTypeAssertion)
fn visit_mut_ts_type_element(&mut self, n: &mut TsTypeElement)
fn visit_mut_ts_type_elements(&mut self, n: &mut Vec<TsTypeElement, Global>)
fn visit_mut_ts_type_lit(&mut self, n: &mut TsTypeLit)
fn visit_mut_ts_type_operator(&mut self, n: &mut TsTypeOperator)
fn visit_mut_ts_type_operator_op(&mut self, n: &mut TsTypeOperatorOp)
fn visit_mut_ts_type_param(&mut self, n: &mut TsTypeParam)
fn visit_mut_ts_type_param_decl(&mut self, n: &mut TsTypeParamDecl)
fn visit_mut_ts_type_param_instantiation(
&mut self,
n: &mut TsTypeParamInstantiation
)
fn visit_mut_ts_type_params(&mut self, n: &mut Vec<TsTypeParam, Global>)
fn visit_mut_ts_type_predicate(&mut self, n: &mut TsTypePredicate)
fn visit_mut_ts_type_query(&mut self, n: &mut TsTypeQuery)
fn visit_mut_ts_type_query_expr(&mut self, n: &mut TsTypeQueryExpr)
fn visit_mut_ts_type_ref(&mut self, n: &mut TsTypeRef)
fn visit_mut_ts_types(&mut self, n: &mut Vec<Box<TsType, Global>, Global>)
fn visit_mut_ts_union_or_intersection_type(
&mut self,
n: &mut TsUnionOrIntersectionType
)
fn visit_mut_ts_union_type(&mut self, n: &mut TsUnionType)
fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr)
fn visit_mut_unary_op(&mut self, n: &mut UnaryOp)
fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr)
fn visit_mut_update_op(&mut self, n: &mut UpdateOp)
fn visit_mut_var_decl(&mut self, n: &mut VarDecl)
fn visit_mut_var_decl_kind(&mut self, n: &mut VarDeclKind)
fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr)
fn visit_mut_var_decl_or_pat(&mut self, n: &mut VarDeclOrPat)
fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator)
fn visit_mut_var_declarators(&mut self, n: &mut Vec<VarDeclarator, Global>)
fn visit_mut_while_stmt(&mut self, n: &mut WhileStmt)
fn visit_mut_with_stmt(&mut self, n: &mut WithStmt)
fn visit_mut_yield_expr(&mut self, n: &mut YieldExpr)
sourceimpl<L, R> Write for Either<L, R> where
L: Write,
R: Write,
impl<L, R> Write for Either<L, R> where
L: Write,
R: Write,
Either<L, R>
implements Write
if both L
and R
do.
Requires crate feature "use_std"
sourcefn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
Write a buffer into this writer, returning how many bytes were written. Read more
sourcefn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
sourcefn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)Determines if this Write
r has an efficient write_vectored
implementation. Read more
1.0.0 · sourcefn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer. Read more
sourcefn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
write_all_vectored
)Attempts to write multiple buffers into this writer. Read more
impl<L, R> Copy for Either<L, R> where
L: Copy,
R: Copy,
impl<L, R> Eq for Either<L, R> where
L: Eq,
R: Eq,
impl<L, R> FusedIterator for Either<L, R> where
L: FusedIterator,
R: FusedIterator<Item = <L as Iterator>::Item>,
impl<L, R> StructuralEq for Either<L, R>
impl<L, R> StructuralPartialEq for Either<L, R>
Auto Trait Implementations
impl<L, R> RefUnwindSafe for Either<L, R> where
L: RefUnwindSafe,
R: RefUnwindSafe,
impl<L, R> Send for Either<L, R> where
L: Send,
R: Send,
impl<L, R> Sync for Either<L, R> where
L: Sync,
R: Sync,
impl<L, R> Unpin for Either<L, R> where
L: Unpin,
R: Unpin,
impl<L, R> UnwindSafe for Either<L, R> where
L: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
type ArchivedMetadata = ()
type ArchivedMetadata = ()
The archived version of the pointer metadata for this type.
fn pointer_metadata(
&<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata(
&<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
Converts some archived metadata to the pointer metadata for itself.
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<F, W, T, D> Deserialize<With<T, W>, D> for F where
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
impl<F, W, T, D> Deserialize<With<T, W>, D> for F where
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
Deserializes using the given deserializer
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
impl<T> Error for T where
T: 'static + Error,
impl<T> Error for T where
T: 'static + Error,
sourceimpl<It> IdentifyLast for It where
It: Iterator,
impl<It> IdentifyLast for It where
It: Iterator,
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<I> IntoIterator for I where
I: Iterator,
impl<I> IntoIterator for I where
I: Iterator,
sourceimpl<I> IteratorExt for I where
I: Iterator,
impl<I> IteratorExt for I where
I: Iterator,
sourcefn chain_with<F, I>(
self,
f: F
) -> ChainWith<Self, F, <I as IntoIterator>::IntoIter>ⓘNotable traits for ChainWith<B, F, <I as IntoIterator>::IntoIter>impl<B, F, I> Iterator for ChainWith<B, F, <I as IntoIterator>::IntoIter> where
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = <B as Iterator>::Item>, type Item = <I as IntoIterator>::Item;
where
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
fn chain_with<F, I>(
self,
f: F
) -> ChainWith<Self, F, <I as IntoIterator>::IntoIter>ⓘNotable traits for ChainWith<B, F, <I as IntoIterator>::IntoIter>impl<B, F, I> Iterator for ChainWith<B, F, <I as IntoIterator>::IntoIter> where
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = <B as Iterator>::Item>, type Item = <I as IntoIterator>::Item;
where
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = <B as Iterator>::Item>, type Item = <I as IntoIterator>::Item;
Copied from https://stackoverflow.com/a/49456265/6193633
impl<T> SpanExt for T where
T: Spanned,
impl<T> SpanExt for T where
T: Spanned,
fn is_synthesized(&self) -> bool
fn starts_on_new_line(&self, format: ListFormat) -> bool
fn comment_range(&self) -> Span
fn comment_range(&self) -> Span
Gets a custom text range to use when emitting comments.
impl<I> UnicodeNormalization<I> for I where
I: Iterator<Item = char>,
impl<I> UnicodeNormalization<I> for I where
I: Iterator<Item = char>,
fn nfd(self) -> Decompositions<I>
fn nfd(self) -> Decompositions<I>
Returns an iterator over the string in Unicode Normalization Form D (canonical decomposition). Read more
fn nfkd(self) -> Decompositions<I>
fn nfkd(self) -> Decompositions<I>
Returns an iterator over the string in Unicode Normalization Form KD (compatibility decomposition). Read more
fn nfc(self) -> Recompositions<I>
fn nfc(self) -> Recompositions<I>
An Iterator over the string in Unicode Normalization Form C (canonical decomposition followed by canonical composition). Read more
fn nfkc(self) -> Recompositions<I>
fn nfkc(self) -> Recompositions<I>
An Iterator over the string in Unicode Normalization Form KC (compatibility decomposition followed by canonical composition). Read more
fn cjk_compat_variants(self) -> Replacements<I>
fn cjk_compat_variants(self) -> Replacements<I>
A transformation which replaces CJK Compatibility Ideograph codepoints with normal forms using Standardized Variation Sequences. This is not part of the canonical or compatibility decomposition algorithms, but performing it before those algorithms produces normalized output which better preserves the intent of the original text. Read more
fn stream_safe(self) -> StreamSafe<I>
fn stream_safe(self) -> StreamSafe<I>
An Iterator over the string with Conjoining Grapheme Joiner characters inserted according to the Stream-Safe Text Process (UAX15-D4) Read more
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more