Enum swc_core::ecma::utils::swc_common::pass::Either

pub enum Either<L, R> {
    Left(L),
    Right(R),
}

Available on crate features __ecma and __utils only.

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

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

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);

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);

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);

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));

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

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"));

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

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));

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

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

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

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

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

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"));

pub fn map_left<F, M>(self, f: F) -> Either<M, R>

where F: FnOnce(L) -> M,

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));

pub fn map_right<F, S>(self, f: F) -> Either<L, S>

where F: FnOnce(R) -> S,

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));

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S>

where F: FnOnce(L) -> M, G: FnOnce(R) -> S,

Apply the functions f and g to the Left and Right variants respectively. This is equivalent to bimap in functional programming.

use either::*;

let f = |s: String| s.len();
let g = |u: u8| u.to_string();

let left: Either<String, u8> = Left("loopy".into());
assert_eq!(left.map_either(f, g), Left(5));

let right: Either<String, u8> = Right(42);
assert_eq!(right.map_either(f, g), Right("42".into()));

pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G ) -> Either<M, S>

where F: FnOnce(Ctx, L) -> M, G: FnOnce(Ctx, R) -> S,

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

use either::*;

let mut sum = 0;

// Both closures want to update the same value, so pass it as context.
let mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };
let mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };

let left: Either<String, usize> = Left("loopy".into());
assert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left("LOOPY".into()));

let right: Either<String, usize> = Right(42);
assert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right("42".into()));

assert_eq!(sum, 47);

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);

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]);

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>

where F: FnOnce(L) -> Either<S, R>,

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));

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>

where F: FnOnce(R) -> Either<L, S>,

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));

pub fn into_iter( self ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>

where L: IntoIterator, R: IntoIterator<Item = <L as IntoIterator>::Item>,

Convert the inner value to an iterator.

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

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]));

pub fn iter( &self ) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Borrow the inner value as an iterator.

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

use either::*;

let left: Either<_, &[u32]> = Left(vec![2, 3]);
let mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);
let mut all = vec![1];
all.extend(left.iter());
all.extend(right.iter());
assert_eq!(all, vec![1, 2, 3, 4, 5]);

pub fn iter_mut( &mut self ) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Mutably borrow the inner value as an iterator.

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

use either::*;

let mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);
for l in left.iter_mut() {
    *l *= *l
}
assert_eq!(left, Left(vec![4, 9]));

let mut inner = [4, 5];
let mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);
for r in right.iter_mut() {
    *r *= *r
}
assert_eq!(inner, [16, 25]);

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

where L: IntoIterator, R: IntoIterator,

Converts an Either of Iterators to be an Iterator of Eithers

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

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

pub fn factor_iter( &self ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>

where &'a L: for<'a> IntoIterator, &'a R: for<'a> IntoIterator,

Borrows an Either of Iterators to be an Iterator of Eithers

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

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

pub fn factor_iter_mut( &mut self ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>

where &'a mut L: for<'a> IntoIterator, &'a mut R: for<'a> IntoIterator,

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

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

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

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");

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());

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");

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");

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);

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);

pub fn unwrap_left(self) -> L

where R: Debug,

Returns the left value

Examples

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

Panics

When Either is a Right value

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

pub fn unwrap_right(self) -> R

where L: Debug,

Returns the right value

Examples

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

Panics

When Either is a Left value

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

pub fn expect_left(self, msg: &str) -> L

where R: Debug,

Returns the left value

Examples

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

Panics

When Either is a Right value

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

pub fn expect_right(self, msg: &str) -> R

where L: Debug,

Returns the right value

Examples

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

Panics

When Either is a Left value

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

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);

impl<L, R> Either<Option<L>, Option<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())));

impl<L, R, E> Either<Result<L, E>, Result<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())));

impl<T, L, R> Either<Result<T, L>, Result<T, 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())));

impl<T, L, R> Either<(T, L), (T, 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);

impl<T, L, R> Either<(L, T), (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);

impl<T> Either<T, 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);

pub fn map<F, M>(self, f: F) -> Either<M, M>

where F: FnOnce(T) -> M,

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

impl<L, R, Target> AsMut<[Target]> for Either<L, R>

where L: AsMut<[Target]>, R: AsMut<[Target]>,

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

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

impl<L, R> AsMut<CStr> for Either<L, R>

where L: AsMut<CStr>, R: AsMut<CStr>,

Requires crate feature use_std.

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

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

impl<L, R> AsMut<OsStr> for Either<L, R>

where L: AsMut<OsStr>, R: AsMut<OsStr>,

Requires crate feature use_std.

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

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

impl<L, R> AsMut<Path> for Either<L, R>

where L: AsMut<Path>, R: AsMut<Path>,

Requires crate feature use_std.

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

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

impl<L, R, Target> AsMut<Target> for Either<L, R>

where L: AsMut<Target>, R: AsMut<Target>,

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

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

impl<L, R> AsMut<str> for Either<L, R>

where L: AsMut<str>, R: AsMut<str>,

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

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

impl<L, R, Target> AsRef<[Target]> for Either<L, R>

where L: AsRef<[Target]>, R: AsRef<[Target]>,

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

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

impl<L, R> AsRef<CStr> for Either<L, R>

where L: AsRef<CStr>, R: AsRef<CStr>,

Requires crate feature use_std.

fn as_ref(&self) -> &CStr

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

impl<L, R> AsRef<OsStr> for Either<L, R>

where L: AsRef<OsStr>, R: AsRef<OsStr>,

Requires crate feature use_std.

fn as_ref(&self) -> &OsStr

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

impl<L, R> AsRef<Path> for Either<L, R>

where L: AsRef<Path>, R: AsRef<Path>,

Requires crate feature use_std.

fn as_ref(&self) -> &Path

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

impl<L, R, Target> AsRef<Target> for Either<L, R>

where L: AsRef<Target>, R: AsRef<Target>,

fn as_ref(&self) -> &Target

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

impl<L, R> AsRef<str> for Either<L, R>

where L: AsRef<str>, R: AsRef<str>,

fn as_ref(&self) -> &str

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

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

where L: BufRead, R: BufRead,

Requires crate feature "use_std"

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.

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.

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

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

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 String buffer.

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

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

Check if the underlying Read has any data left to be read.

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

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

Skip all bytes until the delimiter byte or EOF is reached.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

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

where L: Clone, R: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where L: Debug, R: Debug,

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

Formats the value using the given formatter.

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

where L: Deref, R: Deref<Target = <L as Deref>::Target>,

type Target = <L as Deref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

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

where L: DerefMut, R: DerefMut<Target = <L as Deref>::Target>,

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

Mutably dereferences the value.

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

where L: Display, R: Display,

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

Formats the value using the given formatter.

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

where L: DoubleEndedIterator, R: DoubleEndedIterator<Item = <L as Iterator>::Item>,

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

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

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.

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

where P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

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

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

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

Advances the iterator from the back by n elements.

fn nth_back(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element from the end of the iterator.

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes elements starting from the back of the iterator.

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

where L: Error, R: Error,

Either implements Error if both L and R implement it.

Requires crate feature "use_std"

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

The lower-level source of this error, if any.

fn description(&self) -> &str

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

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

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

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

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

Provides type based access to context intended for error reports.

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

where L: ExactSizeIterator, R: ExactSizeIterator<Item = <L as Iterator>::Item>,

fn len(&self) -> usize

Returns the exact remaining length of the iterator.

fn is_empty(&self) -> bool

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

Returns true if the iterator is empty.

impl<L, R, A> Extend<A> for Either<L, R>

where L: Extend<A>, R: Extend<A>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<A, B> Fold for Either<A, B>

where A: Fold, B: Fold,

fn fold_accessibility(&mut self, n: Accessibility) -> Accessibility

This method can be overridden to customize the visitor behavior.

fn fold_array_lit(&mut self, n: ArrayLit) -> ArrayLit

This method can be overridden to customize the visitor behavior.

fn fold_array_pat(&mut self, n: ArrayPat) -> ArrayPat

This method can be overridden to customize the visitor behavior.

fn fold_arrow_expr(&mut self, n: ArrowExpr) -> ArrowExpr

This method can be overridden to customize the visitor behavior.

fn fold_assign_expr(&mut self, n: AssignExpr) -> AssignExpr

This method can be overridden to customize the visitor behavior.

fn fold_assign_op(&mut self, n: AssignOp) -> AssignOp

This method can be overridden to customize the visitor behavior.

fn fold_assign_pat(&mut self, n: AssignPat) -> AssignPat

This method can be overridden to customize the visitor behavior.

fn fold_assign_pat_prop(&mut self, n: AssignPatProp) -> AssignPatProp

This method can be overridden to customize the visitor behavior.

fn fold_assign_prop(&mut self, n: AssignProp) -> AssignProp

This method can be overridden to customize the visitor behavior.

fn fold_assign_target(&mut self, n: AssignTarget) -> AssignTarget

This method can be overridden to customize the visitor behavior.

fn fold_assign_target_pat(&mut self, n: AssignTargetPat) -> AssignTargetPat

This method can be overridden to customize the visitor behavior.

fn fold_atom(&mut self, n: Atom) -> Atom

fn fold_auto_accessor(&mut self, n: AutoAccessor) -> AutoAccessor

This method can be overridden to customize the visitor behavior.

fn fold_await_expr(&mut self, n: AwaitExpr) -> AwaitExpr

This method can be overridden to customize the visitor behavior.

fn fold_big_int(&mut self, n: BigInt) -> BigInt

This method can be overridden to customize the visitor behavior.

fn fold_big_int_value(&mut self, n: BigInt) -> BigInt

fn fold_bin_expr(&mut self, n: BinExpr) -> BinExpr

This method can be overridden to customize the visitor behavior.

fn fold_binary_op(&mut self, n: BinaryOp) -> BinaryOp

This method can be overridden to customize the visitor behavior.

fn fold_binding_ident(&mut self, n: BindingIdent) -> BindingIdent

This method can be overridden to customize the visitor behavior.

fn fold_block_stmt(&mut self, n: BlockStmt) -> BlockStmt

This method can be overridden to customize the visitor behavior.

fn fold_block_stmt_or_expr(&mut self, n: BlockStmtOrExpr) -> BlockStmtOrExpr

This method can be overridden to customize the visitor behavior.

fn fold_bool(&mut self, n: Bool) -> Bool

This method can be overridden to customize the visitor behavior.

fn fold_break_stmt(&mut self, n: BreakStmt) -> BreakStmt

This method can be overridden to customize the visitor behavior.

fn fold_call_expr(&mut self, n: CallExpr) -> CallExpr

This method can be overridden to customize the visitor behavior.

fn fold_callee(&mut self, n: Callee) -> Callee

This method can be overridden to customize the visitor behavior.

fn fold_catch_clause(&mut self, n: CatchClause) -> CatchClause

This method can be overridden to customize the visitor behavior.

fn fold_class(&mut self, n: Class) -> Class

This method can be overridden to customize the visitor behavior.

fn fold_class_decl(&mut self, n: ClassDecl) -> ClassDecl

This method can be overridden to customize the visitor behavior.

fn fold_class_expr(&mut self, n: ClassExpr) -> ClassExpr

This method can be overridden to customize the visitor behavior.

fn fold_class_member(&mut self, n: ClassMember) -> ClassMember

This method can be overridden to customize the visitor behavior.

fn fold_class_members(&mut self, n: Vec<ClassMember>) -> Vec<ClassMember>

fn fold_class_method(&mut self, n: ClassMethod) -> ClassMethod

This method can be overridden to customize the visitor behavior.

fn fold_class_prop(&mut self, n: ClassProp) -> ClassProp

This method can be overridden to customize the visitor behavior.

fn fold_computed_prop_name(&mut self, n: ComputedPropName) -> ComputedPropName

This method can be overridden to customize the visitor behavior.

fn fold_cond_expr(&mut self, n: CondExpr) -> CondExpr

This method can be overridden to customize the visitor behavior.

fn fold_constructor(&mut self, n: Constructor) -> Constructor

This method can be overridden to customize the visitor behavior.

fn fold_continue_stmt(&mut self, n: ContinueStmt) -> ContinueStmt

This method can be overridden to customize the visitor behavior.

fn fold_debugger_stmt(&mut self, n: DebuggerStmt) -> DebuggerStmt

This method can be overridden to customize the visitor behavior.

fn fold_decl(&mut self, n: Decl) -> Decl

This method can be overridden to customize the visitor behavior.

fn fold_decorator(&mut self, n: Decorator) -> Decorator

This method can be overridden to customize the visitor behavior.

fn fold_decorators(&mut self, n: Vec<Decorator>) -> Vec<Decorator>

fn fold_default_decl(&mut self, n: DefaultDecl) -> DefaultDecl

This method can be overridden to customize the visitor behavior.

fn fold_do_while_stmt(&mut self, n: DoWhileStmt) -> DoWhileStmt

This method can be overridden to customize the visitor behavior.

fn fold_empty_stmt(&mut self, n: EmptyStmt) -> EmptyStmt

This method can be overridden to customize the visitor behavior.

fn fold_export_all(&mut self, n: ExportAll) -> ExportAll

This method can be overridden to customize the visitor behavior.

fn fold_export_decl(&mut self, n: ExportDecl) -> ExportDecl

This method can be overridden to customize the visitor behavior.

fn fold_export_default_decl( &mut self, n: ExportDefaultDecl ) -> ExportDefaultDecl

This method can be overridden to customize the visitor behavior.

fn fold_export_default_expr( &mut self, n: ExportDefaultExpr ) -> ExportDefaultExpr

This method can be overridden to customize the visitor behavior.

fn fold_export_default_specifier( &mut self, n: ExportDefaultSpecifier ) -> ExportDefaultSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_export_named_specifier( &mut self, n: ExportNamedSpecifier ) -> ExportNamedSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_export_namespace_specifier( &mut self, n: ExportNamespaceSpecifier ) -> ExportNamespaceSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_export_specifier(&mut self, n: ExportSpecifier) -> ExportSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_export_specifiers( &mut self, n: Vec<ExportSpecifier> ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, n: Expr) -> Expr

This method can be overridden to customize the visitor behavior.

fn fold_expr_or_spread(&mut self, n: ExprOrSpread) -> ExprOrSpread

This method can be overridden to customize the visitor behavior.

fn fold_expr_or_spreads(&mut self, n: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>

fn fold_expr_stmt(&mut self, n: ExprStmt) -> ExprStmt

This method can be overridden to customize the visitor behavior.

fn fold_exprs(&mut self, n: Vec<Box<Expr>>) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, n: FnDecl) -> FnDecl

This method can be overridden to customize the visitor behavior.

fn fold_fn_expr(&mut self, n: FnExpr) -> FnExpr

This method can be overridden to customize the visitor behavior.

fn fold_for_head(&mut self, n: ForHead) -> ForHead

This method can be overridden to customize the visitor behavior.

fn fold_for_in_stmt(&mut self, n: ForInStmt) -> ForInStmt

This method can be overridden to customize the visitor behavior.

fn fold_for_of_stmt(&mut self, n: ForOfStmt) -> ForOfStmt

This method can be overridden to customize the visitor behavior.

fn fold_for_stmt(&mut self, n: ForStmt) -> ForStmt

This method can be overridden to customize the visitor behavior.

fn fold_function(&mut self, n: Function) -> Function

This method can be overridden to customize the visitor behavior.

fn fold_getter_prop(&mut self, n: GetterProp) -> GetterProp

This method can be overridden to customize the visitor behavior.

fn fold_ident(&mut self, n: Ident) -> Ident

This method can be overridden to customize the visitor behavior.

fn fold_if_stmt(&mut self, n: IfStmt) -> IfStmt

This method can be overridden to customize the visitor behavior.

fn fold_import(&mut self, n: Import) -> Import

This method can be overridden to customize the visitor behavior.

fn fold_import_decl(&mut self, n: ImportDecl) -> ImportDecl

This method can be overridden to customize the visitor behavior.

fn fold_import_default_specifier( &mut self, n: ImportDefaultSpecifier ) -> ImportDefaultSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_import_named_specifier( &mut self, n: ImportNamedSpecifier ) -> ImportNamedSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_import_phase(&mut self, n: ImportPhase) -> ImportPhase

fn fold_import_specifier(&mut self, n: ImportSpecifier) -> ImportSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_import_specifiers( &mut self, n: Vec<ImportSpecifier> ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, n: ImportStarAsSpecifier ) -> ImportStarAsSpecifier

This method can be overridden to customize the visitor behavior.

fn fold_invalid(&mut self, n: Invalid) -> Invalid

This method can be overridden to customize the visitor behavior.

fn fold_jsx_attr(&mut self, n: JSXAttr) -> JSXAttr

This method can be overridden to customize the visitor behavior.

fn fold_jsx_attr_name(&mut self, n: JSXAttrName) -> JSXAttrName

This method can be overridden to customize the visitor behavior.

fn fold_jsx_attr_or_spread(&mut self, n: JSXAttrOrSpread) -> JSXAttrOrSpread

This method can be overridden to customize the visitor behavior.

fn fold_jsx_attr_or_spreads( &mut self, n: Vec<JSXAttrOrSpread> ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value(&mut self, n: JSXAttrValue) -> JSXAttrValue

This method can be overridden to customize the visitor behavior.

fn fold_jsx_closing_element( &mut self, n: JSXClosingElement ) -> JSXClosingElement

This method can be overridden to customize the visitor behavior.

fn fold_jsx_closing_fragment( &mut self, n: JSXClosingFragment ) -> JSXClosingFragment

This method can be overridden to customize the visitor behavior.

fn fold_jsx_element(&mut self, n: JSXElement) -> JSXElement

This method can be overridden to customize the visitor behavior.

fn fold_jsx_element_child(&mut self, n: JSXElementChild) -> JSXElementChild

This method can be overridden to customize the visitor behavior.

fn fold_jsx_element_children( &mut self, n: Vec<JSXElementChild> ) -> Vec<JSXElementChild>

fn fold_jsx_element_name(&mut self, n: JSXElementName) -> JSXElementName

This method can be overridden to customize the visitor behavior.

fn fold_jsx_empty_expr(&mut self, n: JSXEmptyExpr) -> JSXEmptyExpr

This method can be overridden to customize the visitor behavior.

fn fold_jsx_expr(&mut self, n: JSXExpr) -> JSXExpr

This method can be overridden to customize the visitor behavior.

fn fold_jsx_expr_container(&mut self, n: JSXExprContainer) -> JSXExprContainer

This method can be overridden to customize the visitor behavior.

fn fold_jsx_fragment(&mut self, n: JSXFragment) -> JSXFragment

This method can be overridden to customize the visitor behavior.

fn fold_jsx_member_expr(&mut self, n: JSXMemberExpr) -> JSXMemberExpr

This method can be overridden to customize the visitor behavior.

fn fold_jsx_namespaced_name( &mut self, n: JSXNamespacedName ) -> JSXNamespacedName

This method can be overridden to customize the visitor behavior.

fn fold_jsx_object(&mut self, n: JSXObject) -> JSXObject

This method can be overridden to customize the visitor behavior.

fn fold_jsx_opening_element( &mut self, n: JSXOpeningElement ) -> JSXOpeningElement

This method can be overridden to customize the visitor behavior.

fn fold_jsx_opening_fragment( &mut self, n: JSXOpeningFragment ) -> JSXOpeningFragment

This method can be overridden to customize the visitor behavior.

fn fold_jsx_spread_child(&mut self, n: JSXSpreadChild) -> JSXSpreadChild

This method can be overridden to customize the visitor behavior.

fn fold_jsx_text(&mut self, n: JSXText) -> JSXText

This method can be overridden to customize the visitor behavior.

fn fold_key(&mut self, n: Key) -> Key

This method can be overridden to customize the visitor behavior.

fn fold_key_value_pat_prop(&mut self, n: KeyValuePatProp) -> KeyValuePatProp

This method can be overridden to customize the visitor behavior.

fn fold_key_value_prop(&mut self, n: KeyValueProp) -> KeyValueProp

This method can be overridden to customize the visitor behavior.

fn fold_labeled_stmt(&mut self, n: LabeledStmt) -> LabeledStmt

This method can be overridden to customize the visitor behavior.

fn fold_lit(&mut self, n: Lit) -> Lit

This method can be overridden to customize the visitor behavior.

fn fold_member_expr(&mut self, n: MemberExpr) -> MemberExpr

This method can be overridden to customize the visitor behavior.

fn fold_member_prop(&mut self, n: MemberProp) -> MemberProp

This method can be overridden to customize the visitor behavior.

fn fold_meta_prop_expr(&mut self, n: MetaPropExpr) -> MetaPropExpr

This method can be overridden to customize the visitor behavior.

fn fold_meta_prop_kind(&mut self, n: MetaPropKind) -> MetaPropKind

This method can be overridden to customize the visitor behavior.

fn fold_method_kind(&mut self, n: MethodKind) -> MethodKind

This method can be overridden to customize the visitor behavior.

fn fold_method_prop(&mut self, n: MethodProp) -> MethodProp

This method can be overridden to customize the visitor behavior.

fn fold_module(&mut self, n: Module) -> Module

This method can be overridden to customize the visitor behavior.

fn fold_module_decl(&mut self, n: ModuleDecl) -> ModuleDecl

This method can be overridden to customize the visitor behavior.

fn fold_module_export_name(&mut self, n: ModuleExportName) -> ModuleExportName

This method can be overridden to customize the visitor behavior.

fn fold_module_item(&mut self, n: ModuleItem) -> ModuleItem

This method can be overridden to customize the visitor behavior.

fn fold_module_items(&mut self, n: Vec<ModuleItem>) -> Vec<ModuleItem>

fn fold_named_export(&mut self, n: NamedExport) -> NamedExport

This method can be overridden to customize the visitor behavior.

fn fold_new_expr(&mut self, n: NewExpr) -> NewExpr

This method can be overridden to customize the visitor behavior.

fn fold_null(&mut self, n: Null) -> Null

This method can be overridden to customize the visitor behavior.

fn fold_number(&mut self, n: Number) -> Number

This method can be overridden to customize the visitor behavior.

fn fold_object_lit(&mut self, n: ObjectLit) -> ObjectLit

This method can be overridden to customize the visitor behavior.

fn fold_object_pat(&mut self, n: ObjectPat) -> ObjectPat

This method can be overridden to customize the visitor behavior.

fn fold_object_pat_prop(&mut self, n: ObjectPatProp) -> ObjectPatProp

This method can be overridden to customize the visitor behavior.

fn fold_object_pat_props(&mut self, n: Vec<ObjectPatProp>) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, n: Option<Accessibility> ) -> Option<Accessibility>

fn fold_opt_atom(&mut self, n: Option<Atom>) -> Option<Atom>

fn fold_opt_block_stmt(&mut self, n: Option<BlockStmt>) -> Option<BlockStmt>

fn fold_opt_call(&mut self, n: OptCall) -> OptCall

This method can be overridden to customize the visitor behavior.

fn fold_opt_catch_clause( &mut self, n: Option<CatchClause> ) -> Option<CatchClause>

fn fold_opt_chain_base(&mut self, n: OptChainBase) -> OptChainBase

This method can be overridden to customize the visitor behavior.

fn fold_opt_chain_expr(&mut self, n: OptChainExpr) -> OptChainExpr

This method can be overridden to customize the visitor behavior.

fn fold_opt_expr(&mut self, n: Option<Box<Expr>>) -> Option<Box<Expr>>

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>> ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_ident(&mut self, n: Option<Ident>) -> Option<Ident>

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_module_items( &mut self, n: Option<Vec<ModuleItem>> ) -> Option<Vec<ModuleItem>>

fn fold_opt_object_lit( &mut self, n: Option<Box<ObjectLit>> ) -> Option<Box<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>>) -> Option<Box<Stmt>>

fn fold_opt_str(&mut self, n: Option<Box<Str>>) -> Option<Box<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>>) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, n: Option<Box<TsTypeAnn>> ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, n: Option<Box<TsTypeParamDecl>> ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, n: Option<Box<TsTypeParamInstantiation>> ) -> Option<Box<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>> ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats(&mut self, n: Vec<Option<Pat>>) -> Vec<Option<Pat>>

fn fold_param(&mut self, n: Param) -> Param

This method can be overridden to customize the visitor behavior.

fn fold_param_or_ts_param_prop( &mut self, n: ParamOrTsParamProp ) -> ParamOrTsParamProp

This method can be overridden to customize the visitor behavior.

fn fold_param_or_ts_param_props( &mut self, n: Vec<ParamOrTsParamProp> ) -> Vec<ParamOrTsParamProp>

fn fold_params(&mut self, n: Vec<Param>) -> Vec<Param>

fn fold_paren_expr(&mut self, n: ParenExpr) -> ParenExpr

This method can be overridden to customize the visitor behavior.

fn fold_pat(&mut self, n: Pat) -> Pat

This method can be overridden to customize the visitor behavior.

fn fold_pats(&mut self, n: Vec<Pat>) -> Vec<Pat>

fn fold_private_method(&mut self, n: PrivateMethod) -> PrivateMethod

This method can be overridden to customize the visitor behavior.

fn fold_private_name(&mut self, n: PrivateName) -> PrivateName

This method can be overridden to customize the visitor behavior.

fn fold_private_prop(&mut self, n: PrivateProp) -> PrivateProp

This method can be overridden to customize the visitor behavior.

fn fold_program(&mut self, n: Program) -> Program

This method can be overridden to customize the visitor behavior.

fn fold_prop(&mut self, n: Prop) -> Prop

This method can be overridden to customize the visitor behavior.

fn fold_prop_name(&mut self, n: PropName) -> PropName

This method can be overridden to customize the visitor behavior.

fn fold_prop_or_spread(&mut self, n: PropOrSpread) -> PropOrSpread

This method can be overridden to customize the visitor behavior.

fn fold_prop_or_spreads(&mut self, n: Vec<PropOrSpread>) -> Vec<PropOrSpread>

fn fold_regex(&mut self, n: Regex) -> Regex

This method can be overridden to customize the visitor behavior.

fn fold_reserved_unused(&mut self, n: ReservedUnused) -> ReservedUnused

This method can be overridden to customize the visitor behavior.

fn fold_rest_pat(&mut self, n: RestPat) -> RestPat

This method can be overridden to customize the visitor behavior.

fn fold_return_stmt(&mut self, n: ReturnStmt) -> ReturnStmt

This method can be overridden to customize the visitor behavior.

fn fold_script(&mut self, n: Script) -> Script

This method can be overridden to customize the visitor behavior.

fn fold_seq_expr(&mut self, n: SeqExpr) -> SeqExpr

This method can be overridden to customize the visitor behavior.

fn fold_setter_prop(&mut self, n: SetterProp) -> SetterProp

This method can be overridden to customize the visitor behavior.

fn fold_simple_assign_target( &mut self, n: SimpleAssignTarget ) -> SimpleAssignTarget

This method can be overridden to customize the visitor behavior.

fn fold_span(&mut self, n: Span) -> Span

fn fold_spread_element(&mut self, n: SpreadElement) -> SpreadElement

This method can be overridden to customize the visitor behavior.

fn fold_static_block(&mut self, n: StaticBlock) -> StaticBlock

This method can be overridden to customize the visitor behavior.

fn fold_stmt(&mut self, n: Stmt) -> Stmt

This method can be overridden to customize the visitor behavior.

fn fold_stmts(&mut self, n: Vec<Stmt>) -> Vec<Stmt>

fn fold_str(&mut self, n: Str) -> Str

This method can be overridden to customize the visitor behavior.

fn fold_super(&mut self, n: Super) -> Super

This method can be overridden to customize the visitor behavior.

fn fold_super_prop(&mut self, n: SuperProp) -> SuperProp

This method can be overridden to customize the visitor behavior.

fn fold_super_prop_expr(&mut self, n: SuperPropExpr) -> SuperPropExpr

This method can be overridden to customize the visitor behavior.

fn fold_switch_case(&mut self, n: SwitchCase) -> SwitchCase

This method can be overridden to customize the visitor behavior.

fn fold_switch_cases(&mut self, n: Vec<SwitchCase>) -> Vec<SwitchCase>

fn fold_switch_stmt(&mut self, n: SwitchStmt) -> SwitchStmt

This method can be overridden to customize the visitor behavior.

fn fold_tagged_tpl(&mut self, n: TaggedTpl) -> TaggedTpl

This method can be overridden to customize the visitor behavior.

fn fold_this_expr(&mut self, n: ThisExpr) -> ThisExpr

This method can be overridden to customize the visitor behavior.

fn fold_throw_stmt(&mut self, n: ThrowStmt) -> ThrowStmt

This method can be overridden to customize the visitor behavior.

fn fold_tpl(&mut self, n: Tpl) -> Tpl

This method can be overridden to customize the visitor behavior.

fn fold_tpl_element(&mut self, n: TplElement) -> TplElement

This method can be overridden to customize the visitor behavior.

fn fold_tpl_elements(&mut self, n: Vec<TplElement>) -> Vec<TplElement>

fn fold_true_plus_minus(&mut self, n: TruePlusMinus) -> TruePlusMinus

This method can be overridden to customize the visitor behavior.

fn fold_try_stmt(&mut self, n: TryStmt) -> TryStmt

This method can be overridden to customize the visitor behavior.

fn fold_ts_array_type(&mut self, n: TsArrayType) -> TsArrayType

This method can be overridden to customize the visitor behavior.

fn fold_ts_as_expr(&mut self, n: TsAsExpr) -> TsAsExpr

This method can be overridden to customize the visitor behavior.

fn fold_ts_call_signature_decl( &mut self, n: TsCallSignatureDecl ) -> TsCallSignatureDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_conditional_type( &mut self, n: TsConditionalType ) -> TsConditionalType

This method can be overridden to customize the visitor behavior.

fn fold_ts_const_assertion(&mut self, n: TsConstAssertion) -> TsConstAssertion

This method can be overridden to customize the visitor behavior.

fn fold_ts_construct_signature_decl( &mut self, n: TsConstructSignatureDecl ) -> TsConstructSignatureDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_constructor_type( &mut self, n: TsConstructorType ) -> TsConstructorType

This method can be overridden to customize the visitor behavior.

fn fold_ts_entity_name(&mut self, n: TsEntityName) -> TsEntityName

This method can be overridden to customize the visitor behavior.

fn fold_ts_enum_decl(&mut self, n: TsEnumDecl) -> TsEnumDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_enum_member(&mut self, n: TsEnumMember) -> TsEnumMember

This method can be overridden to customize the visitor behavior.

fn fold_ts_enum_member_id(&mut self, n: TsEnumMemberId) -> TsEnumMemberId

This method can be overridden to customize the visitor behavior.

fn fold_ts_enum_members(&mut self, n: Vec<TsEnumMember>) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, n: TsExportAssignment ) -> TsExportAssignment

This method can be overridden to customize the visitor behavior.

fn fold_ts_expr_with_type_args( &mut self, n: TsExprWithTypeArgs ) -> TsExprWithTypeArgs

This method can be overridden to customize the visitor behavior.

fn fold_ts_expr_with_type_args_vec( &mut self, n: Vec<TsExprWithTypeArgs> ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, n: TsExternalModuleRef ) -> TsExternalModuleRef

This method can be overridden to customize the visitor behavior.

fn fold_ts_fn_or_constructor_type( &mut self, n: TsFnOrConstructorType ) -> TsFnOrConstructorType

This method can be overridden to customize the visitor behavior.

fn fold_ts_fn_param(&mut self, n: TsFnParam) -> TsFnParam

This method can be overridden to customize the visitor behavior.

fn fold_ts_fn_params(&mut self, n: Vec<TsFnParam>) -> Vec<TsFnParam>

fn fold_ts_fn_type(&mut self, n: TsFnType) -> TsFnType

This method can be overridden to customize the visitor behavior.

fn fold_ts_getter_signature( &mut self, n: TsGetterSignature ) -> TsGetterSignature

This method can be overridden to customize the visitor behavior.

fn fold_ts_import_equals_decl( &mut self, n: TsImportEqualsDecl ) -> TsImportEqualsDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_import_type(&mut self, n: TsImportType) -> TsImportType

This method can be overridden to customize the visitor behavior.

fn fold_ts_index_signature(&mut self, n: TsIndexSignature) -> TsIndexSignature

This method can be overridden to customize the visitor behavior.

fn fold_ts_indexed_access_type( &mut self, n: TsIndexedAccessType ) -> TsIndexedAccessType

This method can be overridden to customize the visitor behavior.

fn fold_ts_infer_type(&mut self, n: TsInferType) -> TsInferType

This method can be overridden to customize the visitor behavior.

fn fold_ts_instantiation(&mut self, n: TsInstantiation) -> TsInstantiation

This method can be overridden to customize the visitor behavior.

fn fold_ts_interface_body(&mut self, n: TsInterfaceBody) -> TsInterfaceBody

This method can be overridden to customize the visitor behavior.

fn fold_ts_interface_decl(&mut self, n: TsInterfaceDecl) -> TsInterfaceDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_intersection_type( &mut self, n: TsIntersectionType ) -> TsIntersectionType

This method can be overridden to customize the visitor behavior.

fn fold_ts_keyword_type(&mut self, n: TsKeywordType) -> TsKeywordType

This method can be overridden to customize the visitor behavior.

fn fold_ts_keyword_type_kind( &mut self, n: TsKeywordTypeKind ) -> TsKeywordTypeKind

This method can be overridden to customize the visitor behavior.

fn fold_ts_lit(&mut self, n: TsLit) -> TsLit

This method can be overridden to customize the visitor behavior.

fn fold_ts_lit_type(&mut self, n: TsLitType) -> TsLitType

This method can be overridden to customize the visitor behavior.

fn fold_ts_mapped_type(&mut self, n: TsMappedType) -> TsMappedType

This method can be overridden to customize the visitor behavior.

fn fold_ts_method_signature( &mut self, n: TsMethodSignature ) -> TsMethodSignature

This method can be overridden to customize the visitor behavior.

fn fold_ts_module_block(&mut self, n: TsModuleBlock) -> TsModuleBlock

This method can be overridden to customize the visitor behavior.

fn fold_ts_module_decl(&mut self, n: TsModuleDecl) -> TsModuleDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_module_name(&mut self, n: TsModuleName) -> TsModuleName

This method can be overridden to customize the visitor behavior.

fn fold_ts_module_ref(&mut self, n: TsModuleRef) -> TsModuleRef

This method can be overridden to customize the visitor behavior.

fn fold_ts_namespace_body(&mut self, n: TsNamespaceBody) -> TsNamespaceBody

This method can be overridden to customize the visitor behavior.

fn fold_ts_namespace_decl(&mut self, n: TsNamespaceDecl) -> TsNamespaceDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_namespace_export_decl( &mut self, n: TsNamespaceExportDecl ) -> TsNamespaceExportDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_non_null_expr(&mut self, n: TsNonNullExpr) -> TsNonNullExpr

This method can be overridden to customize the visitor behavior.

fn fold_ts_optional_type(&mut self, n: TsOptionalType) -> TsOptionalType

This method can be overridden to customize the visitor behavior.

fn fold_ts_param_prop(&mut self, n: TsParamProp) -> TsParamProp

This method can be overridden to customize the visitor behavior.

fn fold_ts_param_prop_param(&mut self, n: TsParamPropParam) -> TsParamPropParam

This method can be overridden to customize the visitor behavior.

fn fold_ts_parenthesized_type( &mut self, n: TsParenthesizedType ) -> TsParenthesizedType

This method can be overridden to customize the visitor behavior.

fn fold_ts_property_signature( &mut self, n: TsPropertySignature ) -> TsPropertySignature

This method can be overridden to customize the visitor behavior.

fn fold_ts_qualified_name(&mut self, n: TsQualifiedName) -> TsQualifiedName

This method can be overridden to customize the visitor behavior.

fn fold_ts_rest_type(&mut self, n: TsRestType) -> TsRestType

This method can be overridden to customize the visitor behavior.

fn fold_ts_satisfies_expr(&mut self, n: TsSatisfiesExpr) -> TsSatisfiesExpr

This method can be overridden to customize the visitor behavior.

fn fold_ts_setter_signature( &mut self, n: TsSetterSignature ) -> TsSetterSignature

This method can be overridden to customize the visitor behavior.

fn fold_ts_this_type(&mut self, n: TsThisType) -> TsThisType

This method can be overridden to customize the visitor behavior.

fn fold_ts_this_type_or_ident( &mut self, n: TsThisTypeOrIdent ) -> TsThisTypeOrIdent

This method can be overridden to customize the visitor behavior.

fn fold_ts_tpl_lit_type(&mut self, n: TsTplLitType) -> TsTplLitType

This method can be overridden to customize the visitor behavior.

fn fold_ts_tuple_element(&mut self, n: TsTupleElement) -> TsTupleElement

This method can be overridden to customize the visitor behavior.

fn fold_ts_tuple_elements( &mut self, n: Vec<TsTupleElement> ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type(&mut self, n: TsTupleType) -> TsTupleType

This method can be overridden to customize the visitor behavior.

fn fold_ts_type(&mut self, n: TsType) -> TsType

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_alias_decl(&mut self, n: TsTypeAliasDecl) -> TsTypeAliasDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_ann(&mut self, n: TsTypeAnn) -> TsTypeAnn

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_assertion(&mut self, n: TsTypeAssertion) -> TsTypeAssertion

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_element(&mut self, n: TsTypeElement) -> TsTypeElement

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_elements(&mut self, n: Vec<TsTypeElement>) -> Vec<TsTypeElement>

fn fold_ts_type_lit(&mut self, n: TsTypeLit) -> TsTypeLit

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_operator(&mut self, n: TsTypeOperator) -> TsTypeOperator

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_operator_op(&mut self, n: TsTypeOperatorOp) -> TsTypeOperatorOp

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_param(&mut self, n: TsTypeParam) -> TsTypeParam

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_param_decl(&mut self, n: TsTypeParamDecl) -> TsTypeParamDecl

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_param_instantiation( &mut self, n: TsTypeParamInstantiation ) -> TsTypeParamInstantiation

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_params(&mut self, n: Vec<TsTypeParam>) -> Vec<TsTypeParam>

fn fold_ts_type_predicate(&mut self, n: TsTypePredicate) -> TsTypePredicate

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_query(&mut self, n: TsTypeQuery) -> TsTypeQuery

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_query_expr(&mut self, n: TsTypeQueryExpr) -> TsTypeQueryExpr

This method can be overridden to customize the visitor behavior.

fn fold_ts_type_ref(&mut self, n: TsTypeRef) -> TsTypeRef

This method can be overridden to customize the visitor behavior.

fn fold_ts_types(&mut self, n: Vec<Box<TsType>>) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, n: TsUnionOrIntersectionType ) -> TsUnionOrIntersectionType

This method can be overridden to customize the visitor behavior.

fn fold_ts_union_type(&mut self, n: TsUnionType) -> TsUnionType

This method can be overridden to customize the visitor behavior.

fn fold_unary_expr(&mut self, n: UnaryExpr) -> UnaryExpr

This method can be overridden to customize the visitor behavior.

fn fold_unary_op(&mut self, n: UnaryOp) -> UnaryOp

This method can be overridden to customize the visitor behavior.

fn fold_update_expr(&mut self, n: UpdateExpr) -> UpdateExpr

This method can be overridden to customize the visitor behavior.

fn fold_update_op(&mut self, n: UpdateOp) -> UpdateOp

This method can be overridden to customize the visitor behavior.

fn fold_using_decl(&mut self, n: UsingDecl) -> UsingDecl

This method can be overridden to customize the visitor behavior.

fn fold_var_decl(&mut self, n: VarDecl) -> VarDecl

This method can be overridden to customize the visitor behavior.

fn fold_var_decl_kind(&mut self, n: VarDeclKind) -> VarDeclKind

This method can be overridden to customize the visitor behavior.

fn fold_var_decl_or_expr(&mut self, n: VarDeclOrExpr) -> VarDeclOrExpr

This method can be overridden to customize the visitor behavior.

fn fold_var_declarator(&mut self, n: VarDeclarator) -> VarDeclarator

This method can be overridden to customize the visitor behavior.

fn fold_var_declarators(&mut self, n: Vec<VarDeclarator>) -> Vec<VarDeclarator>

fn fold_while_stmt(&mut self, n: WhileStmt) -> WhileStmt

This method can be overridden to customize the visitor behavior.

fn fold_with_stmt(&mut self, n: WithStmt) -> WithStmt

This method can be overridden to customize the visitor behavior.

fn fold_yield_expr(&mut self, n: YieldExpr) -> YieldExpr

This method can be overridden to customize the visitor behavior.

impl<A, B> Fold for Either<A, B>

where A: Fold, B: Fold,

fn fold_absolute_color_base( &mut self, n: AbsoluteColorBase ) -> AbsoluteColorBase

This method can be overridden to customize the visitor behavior.

fn fold_alpha_value(&mut self, n: AlphaValue) -> AlphaValue

This method can be overridden to customize the visitor behavior.

fn fold_an_plus_b(&mut self, n: AnPlusB) -> AnPlusB

This method can be overridden to customize the visitor behavior.

fn fold_an_plus_b_notation(&mut self, n: AnPlusBNotation) -> AnPlusBNotation

This method can be overridden to customize the visitor behavior.

fn fold_angle(&mut self, n: Angle) -> Angle

This method can be overridden to customize the visitor behavior.

fn fold_angle_percentage(&mut self, n: AnglePercentage) -> AnglePercentage

This method can be overridden to customize the visitor behavior.

fn fold_any_namespace(&mut self, n: AnyNamespace) -> AnyNamespace

This method can be overridden to customize the visitor behavior.

fn fold_at_rule(&mut self, n: AtRule) -> AtRule

This method can be overridden to customize the visitor behavior.

fn fold_at_rule_name(&mut self, n: AtRuleName) -> AtRuleName

This method can be overridden to customize the visitor behavior.

fn fold_at_rule_prelude(&mut self, n: AtRulePrelude) -> AtRulePrelude

This method can be overridden to customize the visitor behavior.

fn fold_atom(&mut self, n: Atom) -> Atom

fn fold_attribute_selector(&mut self, n: AttributeSelector) -> AttributeSelector

This method can be overridden to customize the visitor behavior.

fn fold_attribute_selector_matcher( &mut self, n: AttributeSelectorMatcher ) -> AttributeSelectorMatcher

This method can be overridden to customize the visitor behavior.

fn fold_attribute_selector_matcher_value( &mut self, n: AttributeSelectorMatcherValue ) -> AttributeSelectorMatcherValue

fn fold_attribute_selector_modifier( &mut self, n: AttributeSelectorModifier ) -> AttributeSelectorModifier

This method can be overridden to customize the visitor behavior.

fn fold_attribute_selector_value( &mut self, n: AttributeSelectorValue ) -> AttributeSelectorValue

This method can be overridden to customize the visitor behavior.

fn fold_calc_operator(&mut self, n: CalcOperator) -> CalcOperator

This method can be overridden to customize the visitor behavior.

fn fold_calc_operator_type(&mut self, n: CalcOperatorType) -> CalcOperatorType

This method can be overridden to customize the visitor behavior.

fn fold_calc_product(&mut self, n: CalcProduct) -> CalcProduct

This method can be overridden to customize the visitor behavior.

fn fold_calc_product_or_operator( &mut self, n: CalcProductOrOperator ) -> CalcProductOrOperator

This method can be overridden to customize the visitor behavior.

fn fold_calc_product_or_operators( &mut self, n: Vec<CalcProductOrOperator> ) -> Vec<CalcProductOrOperator>

fn fold_calc_sum(&mut self, n: CalcSum) -> CalcSum

This method can be overridden to customize the visitor behavior.

fn fold_calc_value(&mut self, n: CalcValue) -> CalcValue

This method can be overridden to customize the visitor behavior.

fn fold_calc_value_or_operator( &mut self, n: CalcValueOrOperator ) -> CalcValueOrOperator

This method can be overridden to customize the visitor behavior.

fn fold_calc_value_or_operators( &mut self, n: Vec<CalcValueOrOperator> ) -> Vec<CalcValueOrOperator>

fn fold_class_selector(&mut self, n: ClassSelector) -> ClassSelector

This method can be overridden to customize the visitor behavior.

fn fold_cmyk_component(&mut self, n: CmykComponent) -> CmykComponent

This method can be overridden to customize the visitor behavior.

fn fold_color(&mut self, n: Color) -> Color

This method can be overridden to customize the visitor behavior.

fn fold_color_profile_name(&mut self, n: ColorProfileName) -> ColorProfileName

This method can be overridden to customize the visitor behavior.

fn fold_combinator(&mut self, n: Combinator) -> Combinator

This method can be overridden to customize the visitor behavior.

fn fold_combinator_value(&mut self, n: CombinatorValue) -> CombinatorValue

fn fold_complex_selector(&mut self, n: ComplexSelector) -> ComplexSelector

This method can be overridden to customize the visitor behavior.

fn fold_complex_selector_children( &mut self, n: ComplexSelectorChildren ) -> ComplexSelectorChildren

This method can be overridden to customize the visitor behavior.

fn fold_complex_selector_children_vec( &mut self, n: Vec<ComplexSelectorChildren> ) -> Vec<ComplexSelectorChildren>

fn fold_complex_selectors( &mut self, n: Vec<ComplexSelector> ) -> Vec<ComplexSelector>

fn fold_component_value(&mut self, n: ComponentValue) -> ComponentValue

This method can be overridden to customize the visitor behavior.

fn fold_component_values( &mut self, n: Vec<ComponentValue> ) -> Vec<ComponentValue>

fn fold_compound_selector(&mut self, n: CompoundSelector) -> CompoundSelector

This method can be overridden to customize the visitor behavior.

fn fold_compound_selector_list( &mut self, n: CompoundSelectorList ) -> CompoundSelectorList

This method can be overridden to customize the visitor behavior.

fn fold_compound_selectors( &mut self, n: Vec<CompoundSelector> ) -> Vec<CompoundSelector>

fn fold_container_condition( &mut self, n: ContainerCondition ) -> ContainerCondition

This method can be overridden to customize the visitor behavior.

fn fold_container_name(&mut self, n: ContainerName) -> ContainerName

This method can be overridden to customize the visitor behavior.

fn fold_container_query(&mut self, n: ContainerQuery) -> ContainerQuery

This method can be overridden to customize the visitor behavior.

fn fold_container_query_and( &mut self, n: ContainerQueryAnd ) -> ContainerQueryAnd

This method can be overridden to customize the visitor behavior.

fn fold_container_query_not( &mut self, n: ContainerQueryNot ) -> ContainerQueryNot

This method can be overridden to customize the visitor behavior.

fn fold_container_query_or(&mut self, n: ContainerQueryOr) -> ContainerQueryOr

This method can be overridden to customize the visitor behavior.

fn fold_container_query_type( &mut self, n: ContainerQueryType ) -> ContainerQueryType

This method can be overridden to customize the visitor behavior.

fn fold_container_query_types( &mut self, n: Vec<ContainerQueryType> ) -> Vec<ContainerQueryType>

fn fold_custom_highlight_name( &mut self, n: CustomHighlightName ) -> CustomHighlightName

This method can be overridden to customize the visitor behavior.

fn fold_custom_ident(&mut self, n: CustomIdent) -> CustomIdent

This method can be overridden to customize the visitor behavior.

fn fold_custom_idents(&mut self, n: Vec<CustomIdent>) -> Vec<CustomIdent>

fn fold_custom_media_query(&mut self, n: CustomMediaQuery) -> CustomMediaQuery

This method can be overridden to customize the visitor behavior.

fn fold_custom_media_query_media_type( &mut self, n: CustomMediaQueryMediaType ) -> CustomMediaQueryMediaType

This method can be overridden to customize the visitor behavior.

fn fold_custom_property_name( &mut self, n: CustomPropertyName ) -> CustomPropertyName

This method can be overridden to customize the visitor behavior.

fn fold_dashed_ident(&mut self, n: DashedIdent) -> DashedIdent

This method can be overridden to customize the visitor behavior.

fn fold_declaration(&mut self, n: Declaration) -> Declaration

This method can be overridden to customize the visitor behavior.

fn fold_declaration_name(&mut self, n: DeclarationName) -> DeclarationName

This method can be overridden to customize the visitor behavior.

fn fold_declaration_or_at_rule( &mut self, n: DeclarationOrAtRule ) -> DeclarationOrAtRule

This method can be overridden to customize the visitor behavior.

fn fold_delimiter(&mut self, n: Delimiter) -> Delimiter

This method can be overridden to customize the visitor behavior.

fn fold_delimiter_value(&mut self, n: DelimiterValue) -> DelimiterValue

This method can be overridden to customize the visitor behavior.

fn fold_dimension(&mut self, n: Dimension) -> Dimension

This method can be overridden to customize the visitor behavior.

fn fold_document_prelude(&mut self, n: DocumentPrelude) -> DocumentPrelude

This method can be overridden to customize the visitor behavior.

fn fold_document_prelude_matching_function( &mut self, n: DocumentPreludeMatchingFunction ) -> DocumentPreludeMatchingFunction

This method can be overridden to customize the visitor behavior.

fn fold_document_prelude_matching_functions( &mut self, n: Vec<DocumentPreludeMatchingFunction> ) -> Vec<DocumentPreludeMatchingFunction>

fn fold_extension_name(&mut self, n: ExtensionName) -> ExtensionName

This method can be overridden to customize the visitor behavior.

fn fold_family_name(&mut self, n: FamilyName) -> FamilyName

This method can be overridden to customize the visitor behavior.

fn fold_family_names(&mut self, n: Vec<FamilyName>) -> Vec<FamilyName>

fn fold_flex(&mut self, n: Flex) -> Flex

This method can be overridden to customize the visitor behavior.

fn fold_font_feature_values_prelude( &mut self, n: FontFeatureValuesPrelude ) -> FontFeatureValuesPrelude

This method can be overridden to customize the visitor behavior.

fn fold_forgiving_complex_selector( &mut self, n: ForgivingComplexSelector ) -> ForgivingComplexSelector

This method can be overridden to customize the visitor behavior.

fn fold_forgiving_complex_selectors( &mut self, n: Vec<ForgivingComplexSelector> ) -> Vec<ForgivingComplexSelector>

fn fold_forgiving_relative_selector( &mut self, n: ForgivingRelativeSelector ) -> ForgivingRelativeSelector

This method can be overridden to customize the visitor behavior.

fn fold_forgiving_relative_selector_list( &mut self, n: ForgivingRelativeSelectorList ) -> ForgivingRelativeSelectorList

This method can be overridden to customize the visitor behavior.

fn fold_forgiving_relative_selectors( &mut self, n: Vec<ForgivingRelativeSelector> ) -> Vec<ForgivingRelativeSelector>

fn fold_forgiving_selector_list( &mut self, n: ForgivingSelectorList ) -> ForgivingSelectorList

This method can be overridden to customize the visitor behavior.

fn fold_frequency(&mut self, n: Frequency) -> Frequency

This method can be overridden to customize the visitor behavior.

fn fold_frequency_percentage( &mut self, n: FrequencyPercentage ) -> FrequencyPercentage

This method can be overridden to customize the visitor behavior.

fn fold_function(&mut self, n: Function) -> Function

This method can be overridden to customize the visitor behavior.

fn fold_function_name(&mut self, n: FunctionName) -> FunctionName

This method can be overridden to customize the visitor behavior.

fn fold_general_enclosed(&mut self, n: GeneralEnclosed) -> GeneralEnclosed

This method can be overridden to customize the visitor behavior.

fn fold_hex_color(&mut self, n: HexColor) -> HexColor

This method can be overridden to customize the visitor behavior.

fn fold_hue(&mut self, n: Hue) -> Hue

This method can be overridden to customize the visitor behavior.

fn fold_i_32(&mut self, n: i32) -> i32

fn fold_id_selector(&mut self, n: IdSelector) -> IdSelector

This method can be overridden to customize the visitor behavior.

fn fold_ident(&mut self, n: Ident) -> Ident

This method can be overridden to customize the visitor behavior.

fn fold_idents(&mut self, n: Vec<Ident>) -> Vec<Ident>

fn fold_import_conditions(&mut self, n: ImportConditions) -> ImportConditions

This method can be overridden to customize the visitor behavior.

fn fold_import_href(&mut self, n: ImportHref) -> ImportHref

This method can be overridden to customize the visitor behavior.

fn fold_import_layer_name(&mut self, n: ImportLayerName) -> ImportLayerName

This method can be overridden to customize the visitor behavior.

fn fold_import_prelude(&mut self, n: ImportPrelude) -> ImportPrelude

This method can be overridden to customize the visitor behavior.

fn fold_important_flag(&mut self, n: ImportantFlag) -> ImportantFlag

This method can be overridden to customize the visitor behavior.

fn fold_integer(&mut self, n: Integer) -> Integer

This method can be overridden to customize the visitor behavior.

fn fold_keyframe_block(&mut self, n: KeyframeBlock) -> KeyframeBlock

This method can be overridden to customize the visitor behavior.

fn fold_keyframe_selector(&mut self, n: KeyframeSelector) -> KeyframeSelector

This method can be overridden to customize the visitor behavior.

fn fold_keyframe_selectors( &mut self, n: Vec<KeyframeSelector> ) -> Vec<KeyframeSelector>

fn fold_keyframes_name(&mut self, n: KeyframesName) -> KeyframesName

This method can be overridden to customize the visitor behavior.

fn fold_keyframes_pseudo_function( &mut self, n: KeyframesPseudoFunction ) -> KeyframesPseudoFunction

This method can be overridden to customize the visitor behavior.

fn fold_keyframes_pseudo_prefix( &mut self, n: KeyframesPseudoPrefix ) -> KeyframesPseudoPrefix

This method can be overridden to customize the visitor behavior.

fn fold_layer_name(&mut self, n: LayerName) -> LayerName

This method can be overridden to customize the visitor behavior.

fn fold_layer_name_list(&mut self, n: LayerNameList) -> LayerNameList

This method can be overridden to customize the visitor behavior.

fn fold_layer_names(&mut self, n: Vec<LayerName>) -> Vec<LayerName>

fn fold_layer_prelude(&mut self, n: LayerPrelude) -> LayerPrelude

This method can be overridden to customize the visitor behavior.

fn fold_length(&mut self, n: Length) -> Length

This method can be overridden to customize the visitor behavior.

fn fold_length_percentage(&mut self, n: LengthPercentage) -> LengthPercentage

This method can be overridden to customize the visitor behavior.

fn fold_list_of_component_values( &mut self, n: ListOfComponentValues ) -> ListOfComponentValues

This method can be overridden to customize the visitor behavior.

fn fold_media_and(&mut self, n: MediaAnd) -> MediaAnd

This method can be overridden to customize the visitor behavior.

fn fold_media_condition(&mut self, n: MediaCondition) -> MediaCondition

This method can be overridden to customize the visitor behavior.

fn fold_media_condition_all_type( &mut self, n: MediaConditionAllType ) -> MediaConditionAllType

This method can be overridden to customize the visitor behavior.

fn fold_media_condition_all_types( &mut self, n: Vec<MediaConditionAllType> ) -> Vec<MediaConditionAllType>

fn fold_media_condition_type( &mut self, n: MediaConditionType ) -> MediaConditionType

This method can be overridden to customize the visitor behavior.

fn fold_media_condition_without_or( &mut self, n: MediaConditionWithoutOr ) -> MediaConditionWithoutOr

This method can be overridden to customize the visitor behavior.

fn fold_media_condition_without_or_type( &mut self, n: MediaConditionWithoutOrType ) -> MediaConditionWithoutOrType

This method can be overridden to customize the visitor behavior.

fn fold_media_condition_without_or_types( &mut self, n: Vec<MediaConditionWithoutOrType> ) -> Vec<MediaConditionWithoutOrType>

fn fold_media_feature(&mut self, n: MediaFeature) -> MediaFeature

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_boolean( &mut self, n: MediaFeatureBoolean ) -> MediaFeatureBoolean

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_name(&mut self, n: MediaFeatureName) -> MediaFeatureName

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_plain( &mut self, n: MediaFeaturePlain ) -> MediaFeaturePlain

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_range( &mut self, n: MediaFeatureRange ) -> MediaFeatureRange

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_range_comparison( &mut self, n: MediaFeatureRangeComparison ) -> MediaFeatureRangeComparison

fn fold_media_feature_range_interval( &mut self, n: MediaFeatureRangeInterval ) -> MediaFeatureRangeInterval

This method can be overridden to customize the visitor behavior.

fn fold_media_feature_value( &mut self, n: MediaFeatureValue ) -> MediaFeatureValue

This method can be overridden to customize the visitor behavior.

fn fold_media_in_parens(&mut self, n: MediaInParens) -> MediaInParens

This method can be overridden to customize the visitor behavior.

fn fold_media_not(&mut self, n: MediaNot) -> MediaNot

This method can be overridden to customize the visitor behavior.

fn fold_media_or(&mut self, n: MediaOr) -> MediaOr

This method can be overridden to customize the visitor behavior.

fn fold_media_queries(&mut self, n: Vec<MediaQuery>) -> Vec<MediaQuery>

fn fold_media_query(&mut self, n: MediaQuery) -> MediaQuery

This method can be overridden to customize the visitor behavior.

fn fold_media_query_list(&mut self, n: MediaQueryList) -> MediaQueryList

This method can be overridden to customize the visitor behavior.

fn fold_media_type(&mut self, n: MediaType) -> MediaType

This method can be overridden to customize the visitor behavior.

fn fold_named_namespace(&mut self, n: NamedNamespace) -> NamedNamespace

This method can be overridden to customize the visitor behavior.

fn fold_namespace(&mut self, n: Namespace) -> Namespace

This method can be overridden to customize the visitor behavior.

fn fold_namespace_prefix(&mut self, n: NamespacePrefix) -> NamespacePrefix

This method can be overridden to customize the visitor behavior.

fn fold_namespace_prelude(&mut self, n: NamespacePrelude) -> NamespacePrelude

This method can be overridden to customize the visitor behavior.

fn fold_namespace_prelude_uri( &mut self, n: NamespacePreludeUri ) -> NamespacePreludeUri

This method can be overridden to customize the visitor behavior.

fn fold_nesting_selector(&mut self, n: NestingSelector) -> NestingSelector

This method can be overridden to customize the visitor behavior.

fn fold_number(&mut self, n: Number) -> Number

This method can be overridden to customize the visitor behavior.

fn fold_opt_at_rule_prelude( &mut self, n: Option<Box<AtRulePrelude>> ) -> Option<Box<AtRulePrelude>>

fn fold_opt_atom(&mut self, n: Option<Atom>) -> Option<Atom>

fn fold_opt_attribute_selector_matcher( &mut self, n: Option<AttributeSelectorMatcher> ) -> Option<AttributeSelectorMatcher>

fn fold_opt_attribute_selector_modifier( &mut self, n: Option<AttributeSelectorModifier> ) -> Option<AttributeSelectorModifier>

fn fold_opt_attribute_selector_value( &mut self, n: Option<AttributeSelectorValue> ) -> Option<AttributeSelectorValue>

fn fold_opt_combinator(&mut self, n: Option<Combinator>) -> Option<Combinator>

fn fold_opt_container_name( &mut self, n: Option<ContainerName> ) -> Option<ContainerName>

fn fold_opt_forgiving_selector_list( &mut self, n: Option<ForgivingSelectorList> ) -> Option<ForgivingSelectorList>

fn fold_opt_function( &mut self, n: Option<Box<Function>> ) -> Option<Box<Function>>

fn fold_opt_i_32(&mut self, n: Option<i32>) -> Option<i32>

fn fold_opt_ident(&mut self, n: Option<Ident>) -> Option<Ident>

fn fold_opt_import_conditions( &mut self, n: Option<Box<ImportConditions>> ) -> Option<Box<ImportConditions>>

fn fold_opt_import_layer_name( &mut self, n: Option<Box<ImportLayerName>> ) -> Option<Box<ImportLayerName>>

fn fold_opt_important_flag( &mut self, n: Option<ImportantFlag> ) -> Option<ImportantFlag>

fn fold_opt_media_condition_type( &mut self, n: Option<Box<MediaConditionType>> ) -> Option<Box<MediaConditionType>>

fn fold_opt_media_query_list( &mut self, n: Option<Box<MediaQueryList>> ) -> Option<Box<MediaQueryList>>

fn fold_opt_media_type(&mut self, n: Option<MediaType>) -> Option<MediaType>

fn fold_opt_namespace(&mut self, n: Option<Namespace>) -> Option<Namespace>

fn fold_opt_namespace_prefix( &mut self, n: Option<NamespacePrefix> ) -> Option<NamespacePrefix>

fn fold_opt_nesting_selector( &mut self, n: Option<NestingSelector> ) -> Option<NestingSelector>

fn fold_opt_number(&mut self, n: Option<Number>) -> Option<Number>

fn fold_opt_page_selector_pseudos( &mut self, n: Option<Vec<PageSelectorPseudo>> ) -> Option<Vec<PageSelectorPseudo>>

fn fold_opt_page_selector_type( &mut self, n: Option<PageSelectorType> ) -> Option<PageSelectorType>

fn fold_opt_pseudo_class_selector_children_vec( &mut self, n: Option<Vec<PseudoClassSelectorChildren>> ) -> Option<Vec<PseudoClassSelectorChildren>>

fn fold_opt_pseudo_element_selector_children_vec( &mut self, n: Option<Vec<PseudoElementSelectorChildren>> ) -> Option<Vec<PseudoElementSelectorChildren>>

fn fold_opt_simple_block( &mut self, n: Option<SimpleBlock> ) -> Option<SimpleBlock>

fn fold_opt_type_selector( &mut self, n: Option<Box<TypeSelector>> ) -> Option<Box<TypeSelector>>

fn fold_opt_url_modifiers( &mut self, n: Option<Vec<UrlModifier>> ) -> Option<Vec<UrlModifier>>

fn fold_opt_url_value( &mut self, n: Option<Box<UrlValue>> ) -> Option<Box<UrlValue>>

fn fold_page_selector(&mut self, n: PageSelector) -> PageSelector

This method can be overridden to customize the visitor behavior.

fn fold_page_selector_list(&mut self, n: PageSelectorList) -> PageSelectorList

This method can be overridden to customize the visitor behavior.

fn fold_page_selector_pseudo( &mut self, n: PageSelectorPseudo ) -> PageSelectorPseudo

This method can be overridden to customize the visitor behavior.

fn fold_page_selector_pseudos( &mut self, n: Vec<PageSelectorPseudo> ) -> Vec<PageSelectorPseudo>

fn fold_page_selector_type(&mut self, n: PageSelectorType) -> PageSelectorType

This method can be overridden to customize the visitor behavior.

fn fold_page_selectors(&mut self, n: Vec<PageSelector>) -> Vec<PageSelector>

fn fold_percentage(&mut self, n: Percentage) -> Percentage

This method can be overridden to customize the visitor behavior.

fn fold_pseudo_class_selector( &mut self, n: PseudoClassSelector ) -> PseudoClassSelector

This method can be overridden to customize the visitor behavior.

fn fold_pseudo_class_selector_children( &mut self, n: PseudoClassSelectorChildren ) -> PseudoClassSelectorChildren

This method can be overridden to customize the visitor behavior.

fn fold_pseudo_class_selector_children_vec( &mut self, n: Vec<PseudoClassSelectorChildren> ) -> Vec<PseudoClassSelectorChildren>

fn fold_pseudo_element_selector( &mut self, n: PseudoElementSelector ) -> PseudoElementSelector

This method can be overridden to customize the visitor behavior.

fn fold_pseudo_element_selector_children( &mut self, n: PseudoElementSelectorChildren ) -> PseudoElementSelectorChildren

This method can be overridden to customize the visitor behavior.

fn fold_pseudo_element_selector_children_vec( &mut self, n: Vec<PseudoElementSelectorChildren> ) -> Vec<PseudoElementSelectorChildren>

fn fold_qualified_rule(&mut self, n: QualifiedRule) -> QualifiedRule

This method can be overridden to customize the visitor behavior.

fn fold_qualified_rule_prelude( &mut self, n: QualifiedRulePrelude ) -> QualifiedRulePrelude

This method can be overridden to customize the visitor behavior.

fn fold_query_in_parens(&mut self, n: QueryInParens) -> QueryInParens

This method can be overridden to customize the visitor behavior.

fn fold_ratio(&mut self, n: Ratio) -> Ratio

This method can be overridden to customize the visitor behavior.

fn fold_relative_selector(&mut self, n: RelativeSelector) -> RelativeSelector

This method can be overridden to customize the visitor behavior.

fn fold_relative_selector_list( &mut self, n: RelativeSelectorList ) -> RelativeSelectorList

This method can be overridden to customize the visitor behavior.

fn fold_relative_selectors( &mut self, n: Vec<RelativeSelector> ) -> Vec<RelativeSelector>

fn fold_resolution(&mut self, n: Resolution) -> Resolution

This method can be overridden to customize the visitor behavior.

fn fold_rule(&mut self, n: Rule) -> Rule

This method can be overridden to customize the visitor behavior.

fn fold_rules(&mut self, n: Vec<Rule>) -> Vec<Rule>

fn fold_scope_range(&mut self, n: ScopeRange) -> ScopeRange

This method can be overridden to customize the visitor behavior.

fn fold_selector_list(&mut self, n: SelectorList) -> SelectorList

This method can be overridden to customize the visitor behavior.

fn fold_sequence_of_custom_idents( &mut self, n: SequenceOfCustomIdents ) -> SequenceOfCustomIdents

This method can be overridden to customize the visitor behavior.

fn fold_simple_block(&mut self, n: SimpleBlock) -> SimpleBlock

This method can be overridden to customize the visitor behavior.

fn fold_size_feature(&mut self, n: SizeFeature) -> SizeFeature

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_boolean( &mut self, n: SizeFeatureBoolean ) -> SizeFeatureBoolean

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_name(&mut self, n: SizeFeatureName) -> SizeFeatureName

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_plain(&mut self, n: SizeFeaturePlain) -> SizeFeaturePlain

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_range(&mut self, n: SizeFeatureRange) -> SizeFeatureRange

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_range_comparison( &mut self, n: SizeFeatureRangeComparison ) -> SizeFeatureRangeComparison

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_range_interval( &mut self, n: SizeFeatureRangeInterval ) -> SizeFeatureRangeInterval

This method can be overridden to customize the visitor behavior.

fn fold_size_feature_value(&mut self, n: SizeFeatureValue) -> SizeFeatureValue

This method can be overridden to customize the visitor behavior.

fn fold_span(&mut self, n: Span) -> Span

fn fold_str(&mut self, n: Str) -> Str

This method can be overridden to customize the visitor behavior.

fn fold_style_block(&mut self, n: StyleBlock) -> StyleBlock

This method can be overridden to customize the visitor behavior.

fn fold_stylesheet(&mut self, n: Stylesheet) -> Stylesheet

This method can be overridden to customize the visitor behavior.

fn fold_subclass_selector(&mut self, n: SubclassSelector) -> SubclassSelector

This method can be overridden to customize the visitor behavior.

fn fold_subclass_selectors( &mut self, n: Vec<SubclassSelector> ) -> Vec<SubclassSelector>

fn fold_supports_and(&mut self, n: SupportsAnd) -> SupportsAnd

This method can be overridden to customize the visitor behavior.

fn fold_supports_condition(&mut self, n: SupportsCondition) -> SupportsCondition

This method can be overridden to customize the visitor behavior.

fn fold_supports_condition_type( &mut self, n: SupportsConditionType ) -> SupportsConditionType

This method can be overridden to customize the visitor behavior.

fn fold_supports_condition_types( &mut self, n: Vec<SupportsConditionType> ) -> Vec<SupportsConditionType>

fn fold_supports_feature(&mut self, n: SupportsFeature) -> SupportsFeature

This method can be overridden to customize the visitor behavior.

fn fold_supports_in_parens(&mut self, n: SupportsInParens) -> SupportsInParens

This method can be overridden to customize the visitor behavior.

fn fold_supports_not(&mut self, n: SupportsNot) -> SupportsNot

This method can be overridden to customize the visitor behavior.

fn fold_supports_or(&mut self, n: SupportsOr) -> SupportsOr

This method can be overridden to customize the visitor behavior.

fn fold_tag_name_selector(&mut self, n: TagNameSelector) -> TagNameSelector

This method can be overridden to customize the visitor behavior.

fn fold_time(&mut self, n: Time) -> Time

This method can be overridden to customize the visitor behavior.

fn fold_time_percentage(&mut self, n: TimePercentage) -> TimePercentage

This method can be overridden to customize the visitor behavior.

fn fold_token(&mut self, n: Token) -> Token

fn fold_token_and_span(&mut self, n: TokenAndSpan) -> TokenAndSpan

This method can be overridden to customize the visitor behavior.

fn fold_type_selector(&mut self, n: TypeSelector) -> TypeSelector

This method can be overridden to customize the visitor behavior.

fn fold_unicode_range(&mut self, n: UnicodeRange) -> UnicodeRange

This method can be overridden to customize the visitor behavior.

fn fold_universal_selector(&mut self, n: UniversalSelector) -> UniversalSelector

This method can be overridden to customize the visitor behavior.

fn fold_unknown_dimension(&mut self, n: UnknownDimension) -> UnknownDimension

This method can be overridden to customize the visitor behavior.

fn fold_url(&mut self, n: Url) -> Url

This method can be overridden to customize the visitor behavior.

fn fold_url_modifier(&mut self, n: UrlModifier) -> UrlModifier

This method can be overridden to customize the visitor behavior.

fn fold_url_modifiers(&mut self, n: Vec<UrlModifier>) -> Vec<UrlModifier>

fn fold_url_value(&mut self, n: UrlValue) -> UrlValue

This method can be overridden to customize the visitor behavior.

fn fold_url_value_raw(&mut self, n: UrlValueRaw) -> UrlValueRaw

This method can be overridden to customize the visitor behavior.

fn fold_wq_name(&mut self, n: WqName) -> WqName

This method can be overridden to customize the visitor behavior.

impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>

fn from(either: Either<A, B>) -> EitherOrBoth<A, B>

Converts to this type from the input type.

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

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

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

Converts to this type from the input type.

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

where L: Future, R: Future<Output = <L as Future>::Output>,

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

type Output = <L as Future>::Output

The type of value produced on completion.

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

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

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

where L: Hash, R: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

where L: IndexedParallelIterator, R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,

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

where C: Consumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn len(&self) -> usize

Produces an exact count of how many items this iterator will produce, presuming no panic occurs.

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

where CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

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

Collects the results of the iterator into the specified vector. The vector is always cleared before execution begins. If possible, reusing the vector across calls can lead to better performance since it reuses the same backing buffer.

fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)

where Self: IndexedParallelIterator<Item = (A, B)>, A: Send, B: Send,

Unzips the results of the iterator into the specified vectors. The vectors are always cleared before execution begins. If possible, reusing the vectors across calls can lead to better performance since they reuse the same backing buffer.

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

where Z: IntoParallelIterator, <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

Iterates over tuples (A, B), where the items A are from this iterator and B are from the iterator given as argument. Like the zip method on ordinary iterators, if the two iterators are of unequal length, you only get the items they have in common.

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

where Z: IntoParallelIterator, <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

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

fn interleave<I>( self, other: I ) -> Interleave<Self, <I as IntoParallelIterator>::Iter>

where I: IntoParallelIterator<Item = Self::Item>, <I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,

Interleaves elements of this iterator and the other given iterator. Alternately yields elements from this iterator and the given iterator, until both are exhausted. If one iterator is exhausted before the other, the last elements are provided from the other.

fn interleave_shortest<I>( self, other: I ) -> InterleaveShortest<Self, <I as IntoParallelIterator>::Iter>

where I: IntoParallelIterator<Item = Self::Item>, <I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,

Interleaves elements of this iterator and the other given iterator, until one is exhausted.

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

Splits an iterator up into fixed-size chunks.

fn fold_chunks<T, ID, F>( self, chunk_size: usize, identity: ID, fold_op: F ) -> FoldChunks<Self, ID, F>

where ID: Fn() -> T + Send + Sync, F: Fn(T, Self::Item) -> T + Send + Sync, T: Send,

Splits an iterator into fixed-size chunks, performing a sequential fold() on each chunk.

fn fold_chunks_with<T, F>( self, chunk_size: usize, init: T, fold_op: F ) -> FoldChunksWith<Self, T, F>

where T: Send + Clone, F: Fn(T, Self::Item) -> T + Send + Sync,

Splits an iterator into fixed-size chunks, performing a sequential fold() on each chunk.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Lexicographically compares the elements of this ParallelIterator with those of another.

fn eq<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are equal to those of another

fn ne<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are unequal to those of another

fn lt<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

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

fn le<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

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

fn ge<I>(self, other: I) -> bool

where I: IntoParallelIterator, <I as IntoParallelIterator>::Iter: IndexedParallelIterator, Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,

Determines if the elements of this ParallelIterator are less or equal to those of another.

fn enumerate(self) -> Enumerate<Self>

Yields an index along with each item.

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

Creates an iterator that steps by the given amount

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

Creates an iterator that skips the first n elements.

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

Creates an iterator that yields the first n elements.

fn position_any<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that matches the given predicate, and returns its index. Like ParallelIterator::find_any, the parallel search will not necessarily find the first match, and once a match is found we’ll attempt to stop processing any more.

fn position_first<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator that matches the given predicate, and returns its index.

fn position_last<P>(self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator that matches the given predicate, and returns its index.

fn positions<P>(self, predicate: P) -> Positions<Self, P>

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for items in the parallel iterator that match the given predicate, and returns their indices.

fn rev(self) -> Rev<Self>

Produces a new iterator with the elements of this iterator in reverse order.

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

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

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

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

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

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

fn into(self) -> Result<R, L>

Converts this type into the (usually inferred) input type.

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.

type Item = <L as Iterator>::Item

The type of the elements being iterated over.

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

Advances the iterator and returns the next value.

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

Returns the bounds on the remaining length of the iterator.

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.

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.

fn count(self) -> usize

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

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

Consumes the iterator, returning the last element.

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

Returns the nth element of the iterator.

fn collect<B>(self) -> B

where B: FromIterator<<Either<L, R> as Iterator>::Item>,

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where B: Default + Extend<<Either<L, R> as Iterator>::Item>, F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Consumes an iterator, creating two collections from it.

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.

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.

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

where P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

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

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.

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.

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

where Self: Sized,

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

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

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

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

Advances the iterator by n elements.

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

where Self: Sized,

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

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

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

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

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

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

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

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

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

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

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

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

where Self: Sized,

Creates an iterator that skips the first n elements.

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

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

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

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

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

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

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

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

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Borrows an iterator, rather than consuming it.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

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

Collects all the items from an iterator into a collection.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

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

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

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, 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.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, 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.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

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

fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

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

Applies function to the elements of iterator and returns the first true result or the first error.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

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

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

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

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

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

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

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

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

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

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

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

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

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

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

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

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

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

Checks if the elements of this iterator are sorted using the given key extraction function.

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

where L: Ord, R: Ord,

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<L, R, T> ParallelExtend<T> for Either<L, R>

where L: ParallelExtend<T>, R: ParallelExtend<T>, T: Send,

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

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

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

where L: ParallelIterator, R: ParallelIterator<Item = <L as ParallelIterator>::Item>,

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

type Item = <L as ParallelIterator>::Item

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

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

where C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

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

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

fn for_each<OP>(self, op: OP)

where OP: Fn(Self::Item) + Sync + Send,

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

fn for_each_with<OP, T>(self, init: T, op: OP)

where OP: Fn(&mut T, Self::Item) + Sync + Send, T: Send + Clone,

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

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)

where OP: Fn(&mut T, Self::Item) + Sync + Send, INIT: Fn() -> T + Sync + Send,

Executes OP on a value returned by init with each item produced by the iterator, in parallel.

fn try_for_each<OP, R>(self, op: OP) -> R

where OP: Fn(Self::Item) -> R + Sync + Send, R: Try<Output = ()> + Send,

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

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R

where OP: Fn(&mut T, Self::Item) -> R + Sync + Send, T: Send + Clone, R: Try<Output = ()> + Send,

Executes a fallible OP on the given init value with each item produced by the iterator, in parallel.

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R

where OP: Fn(&mut T, Self::Item) -> R + Sync + Send, INIT: Fn() -> T + Sync + Send, R: Try<Output = ()> + Send,

Executes a fallible OP on a value returned by init with each item produced by the iterator, in parallel.

fn count(self) -> usize

Counts the number of items in this parallel iterator.

fn map<F, R>(self, map_op: F) -> Map<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: Send,

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

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>

where F: Fn(&mut T, Self::Item) -> R + Sync + Send, T: Send + Clone, R: Send,

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

fn map_init<F, INIT, T, R>( self, init: INIT, map_op: F ) -> MapInit<Self, INIT, F>

where F: Fn(&mut T, Self::Item) -> R + Sync + Send, INIT: Fn() -> T + Sync + Send, R: Send,

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

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone + Send, Self: ParallelIterator<Item = &'a T>,

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

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy + Send, Self: ParallelIterator<Item = &'a T>,

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

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>

where OP: Fn(&Self::Item) + Sync + Send,

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

fn update<F>(self, update_op: F) -> Update<Self, F>

where F: Fn(&mut Self::Item) + Sync + Send,

Mutates each item of this iterator before yielding it.

fn filter<P>(self, filter_op: P) -> Filter<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

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

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

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

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>

where F: Fn(Self::Item) -> PI + Sync + Send, PI: IntoParallelIterator,

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

fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>

where F: Fn(Self::Item) -> SI + Sync + Send, SI: IntoIterator, <SI as IntoIterator>::Item: Send,

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

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item

where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, ID: Fn() -> Self::Item + Sync + Send,

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

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>

where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op. If the iterator is empty, None is returned; otherwise, Some is returned.

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, ID: Fn() -> T + Sync + Send, T: Send,

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

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, T: Send + Clone,

Applies fold_op to the given init value with each item of this iterator, finally producing the value for further use.

fn try_fold<T, R, ID, F>( self, identity: ID, fold_op: F ) -> TryFold<Self, R, ID, F>

where F: Fn(T, Self::Item) -> R + Sync + Send, ID: Fn() -> T + Sync + Send, R: Try<Output = T> + Send,

Performs a fallible parallel fold.

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>

where F: Fn(T, Self::Item) -> R + Sync + Send, R: Try<Output = T> + Send, T: Clone + Send,

Performs a fallible parallel fold with a cloneable init value.

fn sum<S>(self) -> S

where S: Send + Sum<Self::Item> + Sum,

Sums up the items in the iterator.

fn product<P>(self) -> P

where P: Send + Product<Self::Item> + Product,

Multiplies all the items in the iterator.

fn min_by<F>(self, f: F) -> Option<Self::Item>

where F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

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

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>

where K: Ord + Send, F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the minimum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn max_by<F>(self, f: F) -> Option<Self::Item>

where F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

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

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>

where K: Ord + Send, F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the maximum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>

where C: IntoParallelIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both.

fn find_any<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

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

fn find_first<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it.

fn find_last<P>(self, predicate: P) -> Option<Self::Item>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it.

fn find_map_any<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

Applies the given predicate to the items in the parallel iterator and returns any non-None result of the map operation.

fn find_map_first<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

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

fn find_map_last<P, R>(self, predicate: P) -> Option<R>

where P: Fn(Self::Item) -> Option<R> + Sync + Send, R: Send,

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

fn any<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we’ll attempt to stop process the rest of the items. Proving that there’s no match, returning false, does require visiting every item.

fn all<P>(self, predicate: P) -> bool

where P: Fn(Self::Item) -> bool + Sync + Send,

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

fn while_some<T>(self) -> WhileSome<Self>

where Self: ParallelIterator<Item = Option<T>>, T: Send,

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

fn panic_fuse(self) -> PanicFuse<Self>

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

fn collect<C>(self) -> C

where C: FromParallelIterator<Self::Item>,

Creates a fresh collection containing all the elements produced by this parallel iterator.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where Self: ParallelIterator<Item = (A, B)>, FromA: Default + Send + ParallelExtend<A>, FromB: Default + Send + ParallelExtend<B>, A: Send, B: Send,

Unzips the items of a parallel iterator into a pair of arbitrary ParallelExtend containers.

fn partition<A, B, P>(self, predicate: P) -> (A, B)

where A: Default + Send + ParallelExtend<Self::Item>, B: Default + Send + ParallelExtend<Self::Item>, P: Fn(&Self::Item) -> bool + Sync + Send,

Partitions the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Items for which the predicate returns true go into the first container, and the rest go into the second.

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)

where A: Default + Send + ParallelExtend<L>, B: Default + Send + ParallelExtend<R>, P: Fn(Self::Item) -> Either<L, R> + Sync + Send, L: Send, R: Send,

Partitions and maps the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Either::Left items go into the first container, and Either::Right items go into the second.

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

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

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

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

fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that takes elements from anywhere in the original iterator until the given predicate returns false.

fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>

where P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that skips elements from anywhere in the original iterator until the given predicate returns false.

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

where L: PartialEq, R: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

where L: PartialOrd, R: PartialOrd,

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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"

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.

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

Read the exact number of bytes required to fill buf.

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

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

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

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

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

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

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

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

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

Pull some bytes from this source into the specified buffer.

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

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

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

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

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"

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

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

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

Rewind to the beginning of a stream.

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

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

Returns the length of this stream (in bytes).

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

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

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

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

Seeks relative to the current position.

impl<A, B> Spanned for Either<A, B>

where A: Spanned, B: Spanned,

fn span(&self) -> Span

Get span of self.

fn span_lo(&self) -> BytePos

fn span_hi(&self) -> BytePos

impl<A, B> Visit for Either<A, B>

where A: Visit, B: Visit,

fn visit_accessibility(&mut self, n: &Accessibility)

This method can be overridden to customize the visitor behavior.

fn visit_array_lit(&mut self, n: &ArrayLit)

This method can be overridden to customize the visitor behavior.

fn visit_array_pat(&mut self, n: &ArrayPat)

This method can be overridden to customize the visitor behavior.

fn visit_arrow_expr(&mut self, n: &ArrowExpr)

This method can be overridden to customize the visitor behavior.

fn visit_assign_expr(&mut self, n: &AssignExpr)

This method can be overridden to customize the visitor behavior.

fn visit_assign_op(&mut self, n: &AssignOp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_pat(&mut self, n: &AssignPat)

This method can be overridden to customize the visitor behavior.

fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_prop(&mut self, n: &AssignProp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_target(&mut self, n: &AssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)

This method can be overridden to customize the visitor behavior.

fn visit_atom(&mut self, n: &Atom)

fn visit_auto_accessor(&mut self, n: &AutoAccessor)

This method can be overridden to customize the visitor behavior.

fn visit_await_expr(&mut self, n: &AwaitExpr)

This method can be overridden to customize the visitor behavior.

fn visit_big_int(&mut self, n: &BigInt)

This method can be overridden to customize the visitor behavior.

fn visit_big_int_value(&mut self, n: &BigInt)

fn visit_bin_expr(&mut self, n: &BinExpr)

This method can be overridden to customize the visitor behavior.

fn visit_binary_op(&mut self, n: &BinaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_binding_ident(&mut self, n: &BindingIdent)

This method can be overridden to customize the visitor behavior.

fn visit_block_stmt(&mut self, n: &BlockStmt)

This method can be overridden to customize the visitor behavior.

fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_bool(&mut self, n: &Bool)

This method can be overridden to customize the visitor behavior.

fn visit_break_stmt(&mut self, n: &BreakStmt)

This method can be overridden to customize the visitor behavior.

fn visit_call_expr(&mut self, n: &CallExpr)

This method can be overridden to customize the visitor behavior.

fn visit_callee(&mut self, n: &Callee)

This method can be overridden to customize the visitor behavior.

fn visit_catch_clause(&mut self, n: &CatchClause)

This method can be overridden to customize the visitor behavior.

fn visit_class(&mut self, n: &Class)

This method can be overridden to customize the visitor behavior.

fn visit_class_decl(&mut self, n: &ClassDecl)

This method can be overridden to customize the visitor behavior.

fn visit_class_expr(&mut self, n: &ClassExpr)

This method can be overridden to customize the visitor behavior.

fn visit_class_member(&mut self, n: &ClassMember)

This method can be overridden to customize the visitor behavior.

fn visit_class_members(&mut self, n: &[ClassMember])

fn visit_class_method(&mut self, n: &ClassMethod)

This method can be overridden to customize the visitor behavior.

fn visit_class_prop(&mut self, n: &ClassProp)

This method can be overridden to customize the visitor behavior.

fn visit_computed_prop_name(&mut self, n: &ComputedPropName)

This method can be overridden to customize the visitor behavior.

fn visit_cond_expr(&mut self, n: &CondExpr)

This method can be overridden to customize the visitor behavior.

fn visit_constructor(&mut self, n: &Constructor)

This method can be overridden to customize the visitor behavior.

fn visit_continue_stmt(&mut self, n: &ContinueStmt)

This method can be overridden to customize the visitor behavior.

fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)

This method can be overridden to customize the visitor behavior.

fn visit_decl(&mut self, n: &Decl)

This method can be overridden to customize the visitor behavior.

fn visit_decorator(&mut self, n: &Decorator)

This method can be overridden to customize the visitor behavior.

fn visit_decorators(&mut self, n: &[Decorator])

fn visit_default_decl(&mut self, n: &DefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_empty_stmt(&mut self, n: &EmptyStmt)

This method can be overridden to customize the visitor behavior.

fn visit_export_all(&mut self, n: &ExportAll)

This method can be overridden to customize the visitor behavior.

fn visit_export_decl(&mut self, n: &ExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_specifier(&mut self, n: &ExportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])

fn visit_expr(&mut self, n: &Expr)

This method can be overridden to customize the visitor behavior.

fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])

fn visit_expr_stmt(&mut self, n: &ExprStmt)

This method can be overridden to customize the visitor behavior.

fn visit_exprs(&mut self, n: &[Box<Expr>])

fn visit_fn_decl(&mut self, n: &FnDecl)

This method can be overridden to customize the visitor behavior.

fn visit_fn_expr(&mut self, n: &FnExpr)

This method can be overridden to customize the visitor behavior.

fn visit_for_head(&mut self, n: &ForHead)

This method can be overridden to customize the visitor behavior.

fn visit_for_in_stmt(&mut self, n: &ForInStmt)

This method can be overridden to customize the visitor behavior.

fn visit_for_of_stmt(&mut self, n: &ForOfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_for_stmt(&mut self, n: &ForStmt)

This method can be overridden to customize the visitor behavior.

fn visit_function(&mut self, n: &Function)

This method can be overridden to customize the visitor behavior.

fn visit_getter_prop(&mut self, n: &GetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_ident(&mut self, n: &Ident)

This method can be overridden to customize the visitor behavior.

fn visit_if_stmt(&mut self, n: &IfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_import(&mut self, n: &Import)

This method can be overridden to customize the visitor behavior.

fn visit_import_decl(&mut self, n: &ImportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_phase(&mut self, n: &ImportPhase)

fn visit_import_specifier(&mut self, n: &ImportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])

fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_invalid(&mut self, n: &Invalid)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr(&mut self, n: &JSXAttr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])

fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element(&mut self, n: &JSXElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element_child(&mut self, n: &JSXElementChild)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])

fn visit_jsx_element_name(&mut self, n: &JSXElementName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_expr(&mut self, n: &JSXExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_fragment(&mut self, n: &JSXFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_object(&mut self, n: &JSXObject)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_text(&mut self, n: &JSXText)

This method can be overridden to customize the visitor behavior.

fn visit_key(&mut self, n: &Key)

This method can be overridden to customize the visitor behavior.

fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)

This method can be overridden to customize the visitor behavior.

fn visit_key_value_prop(&mut self, n: &KeyValueProp)

This method can be overridden to customize the visitor behavior.

fn visit_labeled_stmt(&mut self, n: &LabeledStmt)

This method can be overridden to customize the visitor behavior.

fn visit_lit(&mut self, n: &Lit)

This method can be overridden to customize the visitor behavior.

fn visit_member_expr(&mut self, n: &MemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_member_prop(&mut self, n: &MemberProp)

This method can be overridden to customize the visitor behavior.

fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)

This method can be overridden to customize the visitor behavior.

fn visit_method_kind(&mut self, n: &MethodKind)

This method can be overridden to customize the visitor behavior.

fn visit_method_prop(&mut self, n: &MethodProp)

This method can be overridden to customize the visitor behavior.

fn visit_module(&mut self, n: &Module)

This method can be overridden to customize the visitor behavior.

fn visit_module_decl(&mut self, n: &ModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_module_export_name(&mut self, n: &ModuleExportName)

This method can be overridden to customize the visitor behavior.

fn visit_module_item(&mut self, n: &ModuleItem)

This method can be overridden to customize the visitor behavior.

fn visit_module_items(&mut self, n: &[ModuleItem])

fn visit_named_export(&mut self, n: &NamedExport)

This method can be overridden to customize the visitor behavior.

fn visit_new_expr(&mut self, n: &NewExpr)

This method can be overridden to customize the visitor behavior.

fn visit_null(&mut self, n: &Null)

This method can be overridden to customize the visitor behavior.

fn visit_number(&mut self, n: &Number)

This method can be overridden to customize the visitor behavior.

fn visit_object_lit(&mut self, n: &ObjectLit)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat(&mut self, n: &ObjectPat)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])

fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)

fn visit_opt_atom(&mut self, n: Option<&Atom>)

fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)

fn visit_opt_call(&mut self, n: &OptCall)

This method can be overridden to customize the visitor behavior.

fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)

fn visit_opt_chain_base(&mut self, n: &OptChainBase)

This method can be overridden to customize the visitor behavior.

fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)

This method can be overridden to customize the visitor behavior.

fn visit_opt_expr(&mut self, n: Option<&Box<Expr>>)

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_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_module_items(&mut self, n: Option<&[ModuleItem]>)

fn visit_opt_object_lit(&mut self, n: Option<&Box<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>>)

fn visit_opt_str(&mut self, n: Option<&Box<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>>)

fn visit_opt_ts_type_ann(&mut self, n: Option<&Box<TsTypeAnn>>)

fn visit_opt_ts_type_param_decl(&mut self, n: Option<&Box<TsTypeParamDecl>>)

fn visit_opt_ts_type_param_instantiation( &mut self, n: Option<&Box<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)

This method can be overridden to customize the visitor behavior.

fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)

This method can be overridden to customize the visitor behavior.

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)

This method can be overridden to customize the visitor behavior.

fn visit_pat(&mut self, n: &Pat)

This method can be overridden to customize the visitor behavior.

fn visit_pats(&mut self, n: &[Pat])

fn visit_private_method(&mut self, n: &PrivateMethod)

This method can be overridden to customize the visitor behavior.

fn visit_private_name(&mut self, n: &PrivateName)

This method can be overridden to customize the visitor behavior.

fn visit_private_prop(&mut self, n: &PrivateProp)

This method can be overridden to customize the visitor behavior.

fn visit_program(&mut self, n: &Program)

This method can be overridden to customize the visitor behavior.

fn visit_prop(&mut self, n: &Prop)

This method can be overridden to customize the visitor behavior.

fn visit_prop_name(&mut self, n: &PropName)

This method can be overridden to customize the visitor behavior.

fn visit_prop_or_spread(&mut self, n: &PropOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])

fn visit_regex(&mut self, n: &Regex)

This method can be overridden to customize the visitor behavior.

fn visit_reserved_unused(&mut self, n: &ReservedUnused)

This method can be overridden to customize the visitor behavior.

fn visit_rest_pat(&mut self, n: &RestPat)

This method can be overridden to customize the visitor behavior.

fn visit_return_stmt(&mut self, n: &ReturnStmt)

This method can be overridden to customize the visitor behavior.

fn visit_script(&mut self, n: &Script)

This method can be overridden to customize the visitor behavior.

fn visit_seq_expr(&mut self, n: &SeqExpr)

This method can be overridden to customize the visitor behavior.

fn visit_setter_prop(&mut self, n: &SetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_span(&mut self, n: &Span)

fn visit_spread_element(&mut self, n: &SpreadElement)

This method can be overridden to customize the visitor behavior.

fn visit_static_block(&mut self, n: &StaticBlock)

This method can be overridden to customize the visitor behavior.

fn visit_stmt(&mut self, n: &Stmt)

This method can be overridden to customize the visitor behavior.

fn visit_stmts(&mut self, n: &[Stmt])

fn visit_str(&mut self, n: &Str)

This method can be overridden to customize the visitor behavior.

fn visit_super(&mut self, n: &Super)

This method can be overridden to customize the visitor behavior.

fn visit_super_prop(&mut self, n: &SuperProp)

This method can be overridden to customize the visitor behavior.

fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_switch_case(&mut self, n: &SwitchCase)

This method can be overridden to customize the visitor behavior.

fn visit_switch_cases(&mut self, n: &[SwitchCase])

fn visit_switch_stmt(&mut self, n: &SwitchStmt)

This method can be overridden to customize the visitor behavior.

fn visit_tagged_tpl(&mut self, n: &TaggedTpl)

This method can be overridden to customize the visitor behavior.

fn visit_this_expr(&mut self, n: &ThisExpr)

This method can be overridden to customize the visitor behavior.

fn visit_throw_stmt(&mut self, n: &ThrowStmt)

This method can be overridden to customize the visitor behavior.

fn visit_tpl(&mut self, n: &Tpl)

This method can be overridden to customize the visitor behavior.

fn visit_tpl_element(&mut self, n: &TplElement)

This method can be overridden to customize the visitor behavior.

fn visit_tpl_elements(&mut self, n: &[TplElement])

fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)

This method can be overridden to customize the visitor behavior.

fn visit_try_stmt(&mut self, n: &TryStmt)

This method can be overridden to customize the visitor behavior.

fn visit_ts_array_type(&mut self, n: &TsArrayType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_as_expr(&mut self, n: &TsAsExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_entity_name(&mut self, n: &TsEntityName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_member(&mut self, n: &TsEnumMember)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])

fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)

This method can be overridden to customize the visitor behavior.

fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)

This method can be overridden to customize the visitor behavior.

fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])

fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_param(&mut self, n: &TsFnParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_params(&mut self, n: &[TsFnParam])

fn visit_ts_fn_type(&mut self, n: &TsFnType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_import_type(&mut self, n: &TsImportType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_infer_type(&mut self, n: &TsInferType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_instantiation(&mut self, n: &TsInstantiation)

This method can be overridden to customize the visitor behavior.

fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)

This method can be overridden to customize the visitor behavior.

fn visit_ts_lit(&mut self, n: &TsLit)

This method can be overridden to customize the visitor behavior.

fn visit_ts_lit_type(&mut self, n: &TsLitType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_mapped_type(&mut self, n: &TsMappedType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_block(&mut self, n: &TsModuleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_name(&mut self, n: &TsModuleName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_ref(&mut self, n: &TsModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_optional_type(&mut self, n: &TsOptionalType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_param_prop(&mut self, n: &TsParamProp)

This method can be overridden to customize the visitor behavior.

fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_rest_type(&mut self, n: &TsRestType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_this_type(&mut self, n: &TsThisType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])

fn visit_ts_tuple_type(&mut self, n: &TsTupleType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type(&mut self, n: &TsType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_element(&mut self, n: &TsTypeElement)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])

fn visit_ts_type_lit(&mut self, n: &TsTypeLit)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param(&mut self, n: &TsTypeParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_params(&mut self, n: &[TsTypeParam])

fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_query(&mut self, n: &TsTypeQuery)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_ref(&mut self, n: &TsTypeRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_types(&mut self, n: &[Box<TsType>])

fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_union_type(&mut self, n: &TsUnionType)

This method can be overridden to customize the visitor behavior.

fn visit_unary_expr(&mut self, n: &UnaryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_unary_op(&mut self, n: &UnaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_update_expr(&mut self, n: &UpdateExpr)

This method can be overridden to customize the visitor behavior.

fn visit_update_op(&mut self, n: &UpdateOp)

This method can be overridden to customize the visitor behavior.

fn visit_using_decl(&mut self, n: &UsingDecl)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl(&mut self, n: &VarDecl)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl_kind(&mut self, n: &VarDeclKind)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_var_declarator(&mut self, n: &VarDeclarator)

This method can be overridden to customize the visitor behavior.

fn visit_var_declarators(&mut self, n: &[VarDeclarator])

fn visit_while_stmt(&mut self, n: &WhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_with_stmt(&mut self, n: &WithStmt)

This method can be overridden to customize the visitor behavior.

fn visit_yield_expr(&mut self, n: &YieldExpr)

This method can be overridden to customize the visitor behavior.

impl<A, B> Visit for Either<A, B>

where A: Visit, B: Visit,

fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)

This method can be overridden to customize the visitor behavior.

fn visit_alpha_value(&mut self, n: &AlphaValue)

This method can be overridden to customize the visitor behavior.

fn visit_an_plus_b(&mut self, n: &AnPlusB)

This method can be overridden to customize the visitor behavior.

fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)

This method can be overridden to customize the visitor behavior.

fn visit_angle(&mut self, n: &Angle)

This method can be overridden to customize the visitor behavior.

fn visit_angle_percentage(&mut self, n: &AnglePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_any_namespace(&mut self, n: &AnyNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule(&mut self, n: &AtRule)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule_name(&mut self, n: &AtRuleName)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_atom(&mut self, n: &Atom)

fn visit_attribute_selector(&mut self, n: &AttributeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_matcher_value( &mut self, n: &AttributeSelectorMatcherValue )

fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)

This method can be overridden to customize the visitor behavior.

fn visit_calc_operator(&mut self, n: &CalcOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product(&mut self, n: &CalcProduct)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product_or_operators(&mut self, n: &[CalcProductOrOperator])

fn visit_calc_sum(&mut self, n: &CalcSum)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value(&mut self, n: &CalcValue)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value_or_operators(&mut self, n: &[CalcValueOrOperator])

fn visit_class_selector(&mut self, n: &ClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_cmyk_component(&mut self, n: &CmykComponent)

This method can be overridden to customize the visitor behavior.

fn visit_color(&mut self, n: &Color)

This method can be overridden to customize the visitor behavior.

fn visit_color_profile_name(&mut self, n: &ColorProfileName)

This method can be overridden to customize the visitor behavior.

fn visit_combinator(&mut self, n: &Combinator)

This method can be overridden to customize the visitor behavior.

fn visit_combinator_value(&mut self, n: &CombinatorValue)

fn visit_complex_selector(&mut self, n: &ComplexSelector)

This method can be overridden to customize the visitor behavior.

fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)

This method can be overridden to customize the visitor behavior.

fn visit_complex_selector_children_vec(&mut self, n: &[ComplexSelectorChildren])

fn visit_complex_selectors(&mut self, n: &[ComplexSelector])

fn visit_component_value(&mut self, n: &ComponentValue)

This method can be overridden to customize the visitor behavior.

fn visit_component_values(&mut self, n: &[ComponentValue])

fn visit_compound_selector(&mut self, n: &CompoundSelector)

This method can be overridden to customize the visitor behavior.

fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_compound_selectors(&mut self, n: &[CompoundSelector])

fn visit_container_condition(&mut self, n: &ContainerCondition)

This method can be overridden to customize the visitor behavior.

fn visit_container_name(&mut self, n: &ContainerName)

This method can be overridden to customize the visitor behavior.

fn visit_container_query(&mut self, n: &ContainerQuery)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_not(&mut self, n: &ContainerQueryNot)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_or(&mut self, n: &ContainerQueryOr)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_type(&mut self, n: &ContainerQueryType)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_types(&mut self, n: &[ContainerQueryType])

fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)

This method can be overridden to customize the visitor behavior.

fn visit_custom_ident(&mut self, n: &CustomIdent)

This method can be overridden to customize the visitor behavior.

fn visit_custom_idents(&mut self, n: &[CustomIdent])

fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)

This method can be overridden to customize the visitor behavior.

fn visit_custom_property_name(&mut self, n: &CustomPropertyName)

This method can be overridden to customize the visitor behavior.

fn visit_dashed_ident(&mut self, n: &DashedIdent)

This method can be overridden to customize the visitor behavior.

fn visit_declaration(&mut self, n: &Declaration)

This method can be overridden to customize the visitor behavior.

fn visit_declaration_name(&mut self, n: &DeclarationName)

This method can be overridden to customize the visitor behavior.

fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)

This method can be overridden to customize the visitor behavior.

fn visit_delimiter(&mut self, n: &Delimiter)

This method can be overridden to customize the visitor behavior.

fn visit_delimiter_value(&mut self, n: &DelimiterValue)

This method can be overridden to customize the visitor behavior.

fn visit_dimension(&mut self, n: &Dimension)

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude(&mut self, n: &DocumentPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude_matching_function( &mut self, n: &DocumentPreludeMatchingFunction )

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude_matching_functions( &mut self, n: &[DocumentPreludeMatchingFunction] )

fn visit_extension_name(&mut self, n: &ExtensionName)

This method can be overridden to customize the visitor behavior.

fn visit_family_name(&mut self, n: &FamilyName)

This method can be overridden to customize the visitor behavior.

fn visit_family_names(&mut self, n: &[FamilyName])

fn visit_flex(&mut self, n: &Flex)

This method can be overridden to customize the visitor behavior.

fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_complex_selectors(&mut self, n: &[ForgivingComplexSelector])

fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_relative_selector_list( &mut self, n: &ForgivingRelativeSelectorList )

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_relative_selectors( &mut self, n: &[ForgivingRelativeSelector] )

fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_frequency(&mut self, n: &Frequency)

This method can be overridden to customize the visitor behavior.

fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_function(&mut self, n: &Function)

This method can be overridden to customize the visitor behavior.

fn visit_function_name(&mut self, n: &FunctionName)

This method can be overridden to customize the visitor behavior.

fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)

This method can be overridden to customize the visitor behavior.

fn visit_hex_color(&mut self, n: &HexColor)

This method can be overridden to customize the visitor behavior.

fn visit_hue(&mut self, n: &Hue)

This method can be overridden to customize the visitor behavior.

fn visit_i_32(&mut self, n: &i32)

fn visit_id_selector(&mut self, n: &IdSelector)

This method can be overridden to customize the visitor behavior.

fn visit_ident(&mut self, n: &Ident)

This method can be overridden to customize the visitor behavior.

fn visit_idents(&mut self, n: &[Ident])

fn visit_import_conditions(&mut self, n: &ImportConditions)

This method can be overridden to customize the visitor behavior.

fn visit_import_href(&mut self, n: &ImportHref)

This method can be overridden to customize the visitor behavior.

fn visit_import_layer_name(&mut self, n: &ImportLayerName)

This method can be overridden to customize the visitor behavior.

fn visit_import_prelude(&mut self, n: &ImportPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_important_flag(&mut self, n: &ImportantFlag)

This method can be overridden to customize the visitor behavior.

fn visit_integer(&mut self, n: &Integer)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_block(&mut self, n: &KeyframeBlock)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_selectors(&mut self, n: &[KeyframeSelector])

fn visit_keyframes_name(&mut self, n: &KeyframesName)

This method can be overridden to customize the visitor behavior.

fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)

This method can be overridden to customize the visitor behavior.

fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)

This method can be overridden to customize the visitor behavior.

fn visit_layer_name(&mut self, n: &LayerName)

This method can be overridden to customize the visitor behavior.

fn visit_layer_name_list(&mut self, n: &LayerNameList)

This method can be overridden to customize the visitor behavior.

fn visit_layer_names(&mut self, n: &[LayerName])

fn visit_layer_prelude(&mut self, n: &LayerPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_length(&mut self, n: &Length)

This method can be overridden to customize the visitor behavior.

fn visit_length_percentage(&mut self, n: &LengthPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)

This method can be overridden to customize the visitor behavior.

fn visit_media_and(&mut self, n: &MediaAnd)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition(&mut self, n: &MediaCondition)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_all_types(&mut self, n: &[MediaConditionAllType])

fn visit_media_condition_type(&mut self, n: &MediaConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or_type( &mut self, n: &MediaConditionWithoutOrType )

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or_types( &mut self, n: &[MediaConditionWithoutOrType] )

fn visit_media_feature(&mut self, n: &MediaFeature)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_name(&mut self, n: &MediaFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_range_comparison( &mut self, n: &MediaFeatureRangeComparison )

fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_media_in_parens(&mut self, n: &MediaInParens)

This method can be overridden to customize the visitor behavior.

fn visit_media_not(&mut self, n: &MediaNot)

This method can be overridden to customize the visitor behavior.

fn visit_media_or(&mut self, n: &MediaOr)

This method can be overridden to customize the visitor behavior.

fn visit_media_queries(&mut self, n: &[MediaQuery])

fn visit_media_query(&mut self, n: &MediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_media_query_list(&mut self, n: &MediaQueryList)

This method can be overridden to customize the visitor behavior.

fn visit_media_type(&mut self, n: &MediaType)

This method can be overridden to customize the visitor behavior.

fn visit_named_namespace(&mut self, n: &NamedNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_namespace(&mut self, n: &Namespace)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)

This method can be overridden to customize the visitor behavior.

fn visit_nesting_selector(&mut self, n: &NestingSelector)

This method can be overridden to customize the visitor behavior.

fn visit_number(&mut self, n: &Number)

This method can be overridden to customize the visitor behavior.

fn visit_opt_at_rule_prelude(&mut self, n: Option<&Box<AtRulePrelude>>)

fn visit_opt_atom(&mut self, n: Option<&Atom>)

fn visit_opt_attribute_selector_matcher( &mut self, n: Option<&AttributeSelectorMatcher> )

fn visit_opt_attribute_selector_modifier( &mut self, n: Option<&AttributeSelectorModifier> )

fn visit_opt_attribute_selector_value( &mut self, n: Option<&AttributeSelectorValue> )

fn visit_opt_combinator(&mut self, n: Option<&Combinator>)

fn visit_opt_container_name(&mut self, n: Option<&ContainerName>)

fn visit_opt_forgiving_selector_list( &mut self, n: Option<&ForgivingSelectorList> )

fn visit_opt_function(&mut self, n: Option<&Box<Function>>)

fn visit_opt_i_32(&mut self, n: Option<&i32>)

fn visit_opt_ident(&mut self, n: Option<&Ident>)

fn visit_opt_import_conditions(&mut self, n: Option<&Box<ImportConditions>>)

fn visit_opt_import_layer_name(&mut self, n: Option<&Box<ImportLayerName>>)

fn visit_opt_important_flag(&mut self, n: Option<&ImportantFlag>)

fn visit_opt_media_condition_type( &mut self, n: Option<&Box<MediaConditionType>> )

fn visit_opt_media_query_list(&mut self, n: Option<&Box<MediaQueryList>>)

fn visit_opt_media_type(&mut self, n: Option<&MediaType>)

fn visit_opt_namespace(&mut self, n: Option<&Namespace>)

fn visit_opt_namespace_prefix(&mut self, n: Option<&NamespacePrefix>)

fn visit_opt_nesting_selector(&mut self, n: Option<&NestingSelector>)

fn visit_opt_number(&mut self, n: Option<&Number>)

fn visit_opt_page_selector_pseudos(&mut self, n: Option<&[PageSelectorPseudo]>)

fn visit_opt_page_selector_type(&mut self, n: Option<&PageSelectorType>)

fn visit_opt_pseudo_class_selector_children_vec( &mut self, n: Option<&[PseudoClassSelectorChildren]> )

fn visit_opt_pseudo_element_selector_children_vec( &mut self, n: Option<&[PseudoElementSelectorChildren]> )

fn visit_opt_simple_block(&mut self, n: Option<&SimpleBlock>)

fn visit_opt_type_selector(&mut self, n: Option<&Box<TypeSelector>>)

fn visit_opt_url_modifiers(&mut self, n: Option<&[UrlModifier]>)

fn visit_opt_url_value(&mut self, n: Option<&Box<UrlValue>>)

fn visit_page_selector(&mut self, n: &PageSelector)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_list(&mut self, n: &PageSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_pseudos(&mut self, n: &[PageSelectorPseudo])

fn visit_page_selector_type(&mut self, n: &PageSelectorType)

This method can be overridden to customize the visitor behavior.

fn visit_page_selectors(&mut self, n: &[PageSelector])

fn visit_percentage(&mut self, n: &Percentage)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector_children( &mut self, n: &PseudoClassSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector_children_vec( &mut self, n: &[PseudoClassSelectorChildren] )

fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_element_selector_children( &mut self, n: &PseudoElementSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_element_selector_children_vec( &mut self, n: &[PseudoElementSelectorChildren] )

fn visit_qualified_rule(&mut self, n: &QualifiedRule)

This method can be overridden to customize the visitor behavior.

fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_query_in_parens(&mut self, n: &QueryInParens)

This method can be overridden to customize the visitor behavior.

fn visit_ratio(&mut self, n: &Ratio)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selector(&mut self, n: &RelativeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selectors(&mut self, n: &[RelativeSelector])

fn visit_resolution(&mut self, n: &Resolution)

This method can be overridden to customize the visitor behavior.

fn visit_rule(&mut self, n: &Rule)

This method can be overridden to customize the visitor behavior.

fn visit_rules(&mut self, n: &[Rule])

fn visit_scope_range(&mut self, n: &ScopeRange)

This method can be overridden to customize the visitor behavior.

fn visit_selector_list(&mut self, n: &SelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)

This method can be overridden to customize the visitor behavior.

fn visit_simple_block(&mut self, n: &SimpleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature(&mut self, n: &SizeFeature)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_name(&mut self, n: &SizeFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range_comparison( &mut self, n: &SizeFeatureRangeComparison )

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_span(&mut self, n: &Span)

fn visit_str(&mut self, n: &Str)

This method can be overridden to customize the visitor behavior.

fn visit_style_block(&mut self, n: &StyleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_stylesheet(&mut self, n: &Stylesheet)

This method can be overridden to customize the visitor behavior.

fn visit_subclass_selector(&mut self, n: &SubclassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_subclass_selectors(&mut self, n: &[SubclassSelector])

fn visit_supports_and(&mut self, n: &SupportsAnd)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition(&mut self, n: &SupportsCondition)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition_types(&mut self, n: &[SupportsConditionType])

fn visit_supports_feature(&mut self, n: &SupportsFeature)

This method can be overridden to customize the visitor behavior.

fn visit_supports_in_parens(&mut self, n: &SupportsInParens)

This method can be overridden to customize the visitor behavior.

fn visit_supports_not(&mut self, n: &SupportsNot)

This method can be overridden to customize the visitor behavior.

fn visit_supports_or(&mut self, n: &SupportsOr)

This method can be overridden to customize the visitor behavior.

fn visit_tag_name_selector(&mut self, n: &TagNameSelector)

This method can be overridden to customize the visitor behavior.

fn visit_time(&mut self, n: &Time)

This method can be overridden to customize the visitor behavior.

fn visit_time_percentage(&mut self, n: &TimePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_token(&mut self, n: &Token)

fn visit_token_and_span(&mut self, n: &TokenAndSpan)

This method can be overridden to customize the visitor behavior.

fn visit_type_selector(&mut self, n: &TypeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_unicode_range(&mut self, n: &UnicodeRange)

This method can be overridden to customize the visitor behavior.

fn visit_universal_selector(&mut self, n: &UniversalSelector)

This method can be overridden to customize the visitor behavior.

fn visit_unknown_dimension(&mut self, n: &UnknownDimension)

This method can be overridden to customize the visitor behavior.

fn visit_url(&mut self, n: &Url)

This method can be overridden to customize the visitor behavior.

fn visit_url_modifier(&mut self, n: &UrlModifier)

This method can be overridden to customize the visitor behavior.

fn visit_url_modifiers(&mut self, n: &[UrlModifier])

fn visit_url_value(&mut self, n: &UrlValue)

This method can be overridden to customize the visitor behavior.

fn visit_url_value_raw(&mut self, n: &UrlValueRaw)

This method can be overridden to customize the visitor behavior.

fn visit_wq_name(&mut self, n: &WqName)

This method can be overridden to customize the visitor behavior.

impl<A, B> VisitAll for Either<A, B>

where A: VisitAll, B: VisitAll,

fn visit_accessibility(&mut self, n: &Accessibility)

This method can be overridden to customize the visitor behavior.

fn visit_array_lit(&mut self, n: &ArrayLit)

This method can be overridden to customize the visitor behavior.

fn visit_array_pat(&mut self, n: &ArrayPat)

This method can be overridden to customize the visitor behavior.

fn visit_arrow_expr(&mut self, n: &ArrowExpr)

This method can be overridden to customize the visitor behavior.

fn visit_assign_expr(&mut self, n: &AssignExpr)

This method can be overridden to customize the visitor behavior.

fn visit_assign_op(&mut self, n: &AssignOp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_pat(&mut self, n: &AssignPat)

This method can be overridden to customize the visitor behavior.

fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_prop(&mut self, n: &AssignProp)

This method can be overridden to customize the visitor behavior.

fn visit_assign_target(&mut self, n: &AssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)

This method can be overridden to customize the visitor behavior.

fn visit_atom(&mut self, n: &Atom)

fn visit_auto_accessor(&mut self, n: &AutoAccessor)

This method can be overridden to customize the visitor behavior.

fn visit_await_expr(&mut self, n: &AwaitExpr)

This method can be overridden to customize the visitor behavior.

fn visit_big_int(&mut self, n: &BigInt)

This method can be overridden to customize the visitor behavior.

fn visit_big_int_value(&mut self, n: &BigInt)

fn visit_bin_expr(&mut self, n: &BinExpr)

This method can be overridden to customize the visitor behavior.

fn visit_binary_op(&mut self, n: &BinaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_binding_ident(&mut self, n: &BindingIdent)

This method can be overridden to customize the visitor behavior.

fn visit_block_stmt(&mut self, n: &BlockStmt)

This method can be overridden to customize the visitor behavior.

fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_bool(&mut self, n: &Bool)

This method can be overridden to customize the visitor behavior.

fn visit_break_stmt(&mut self, n: &BreakStmt)

This method can be overridden to customize the visitor behavior.

fn visit_call_expr(&mut self, n: &CallExpr)

This method can be overridden to customize the visitor behavior.

fn visit_callee(&mut self, n: &Callee)

This method can be overridden to customize the visitor behavior.

fn visit_catch_clause(&mut self, n: &CatchClause)

This method can be overridden to customize the visitor behavior.

fn visit_class(&mut self, n: &Class)

This method can be overridden to customize the visitor behavior.

fn visit_class_decl(&mut self, n: &ClassDecl)

This method can be overridden to customize the visitor behavior.

fn visit_class_expr(&mut self, n: &ClassExpr)

This method can be overridden to customize the visitor behavior.

fn visit_class_member(&mut self, n: &ClassMember)

This method can be overridden to customize the visitor behavior.

fn visit_class_members(&mut self, n: &[ClassMember])

fn visit_class_method(&mut self, n: &ClassMethod)

This method can be overridden to customize the visitor behavior.

fn visit_class_prop(&mut self, n: &ClassProp)

This method can be overridden to customize the visitor behavior.

fn visit_computed_prop_name(&mut self, n: &ComputedPropName)

This method can be overridden to customize the visitor behavior.

fn visit_cond_expr(&mut self, n: &CondExpr)

This method can be overridden to customize the visitor behavior.

fn visit_constructor(&mut self, n: &Constructor)

This method can be overridden to customize the visitor behavior.

fn visit_continue_stmt(&mut self, n: &ContinueStmt)

This method can be overridden to customize the visitor behavior.

fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)

This method can be overridden to customize the visitor behavior.

fn visit_decl(&mut self, n: &Decl)

This method can be overridden to customize the visitor behavior.

fn visit_decorator(&mut self, n: &Decorator)

This method can be overridden to customize the visitor behavior.

fn visit_decorators(&mut self, n: &[Decorator])

fn visit_default_decl(&mut self, n: &DefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_empty_stmt(&mut self, n: &EmptyStmt)

This method can be overridden to customize the visitor behavior.

fn visit_export_all(&mut self, n: &ExportAll)

This method can be overridden to customize the visitor behavior.

fn visit_export_decl(&mut self, n: &ExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)

This method can be overridden to customize the visitor behavior.

fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_specifier(&mut self, n: &ExportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])

fn visit_expr(&mut self, n: &Expr)

This method can be overridden to customize the visitor behavior.

fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])

fn visit_expr_stmt(&mut self, n: &ExprStmt)

This method can be overridden to customize the visitor behavior.

fn visit_exprs(&mut self, n: &[Box<Expr>])

fn visit_fn_decl(&mut self, n: &FnDecl)

This method can be overridden to customize the visitor behavior.

fn visit_fn_expr(&mut self, n: &FnExpr)

This method can be overridden to customize the visitor behavior.

fn visit_for_head(&mut self, n: &ForHead)

This method can be overridden to customize the visitor behavior.

fn visit_for_in_stmt(&mut self, n: &ForInStmt)

This method can be overridden to customize the visitor behavior.

fn visit_for_of_stmt(&mut self, n: &ForOfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_for_stmt(&mut self, n: &ForStmt)

This method can be overridden to customize the visitor behavior.

fn visit_function(&mut self, n: &Function)

This method can be overridden to customize the visitor behavior.

fn visit_getter_prop(&mut self, n: &GetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_ident(&mut self, n: &Ident)

This method can be overridden to customize the visitor behavior.

fn visit_if_stmt(&mut self, n: &IfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_import(&mut self, n: &Import)

This method can be overridden to customize the visitor behavior.

fn visit_import_decl(&mut self, n: &ImportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_phase(&mut self, n: &ImportPhase)

fn visit_import_specifier(&mut self, n: &ImportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])

fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_invalid(&mut self, n: &Invalid)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr(&mut self, n: &JSXAttr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])

fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element(&mut self, n: &JSXElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element_child(&mut self, n: &JSXElementChild)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])

fn visit_jsx_element_name(&mut self, n: &JSXElementName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_expr(&mut self, n: &JSXExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_fragment(&mut self, n: &JSXFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_object(&mut self, n: &JSXObject)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)

This method can be overridden to customize the visitor behavior.

fn visit_jsx_text(&mut self, n: &JSXText)

This method can be overridden to customize the visitor behavior.

fn visit_key(&mut self, n: &Key)

This method can be overridden to customize the visitor behavior.

fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)

This method can be overridden to customize the visitor behavior.

fn visit_key_value_prop(&mut self, n: &KeyValueProp)

This method can be overridden to customize the visitor behavior.

fn visit_labeled_stmt(&mut self, n: &LabeledStmt)

This method can be overridden to customize the visitor behavior.

fn visit_lit(&mut self, n: &Lit)

This method can be overridden to customize the visitor behavior.

fn visit_member_expr(&mut self, n: &MemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_member_prop(&mut self, n: &MemberProp)

This method can be overridden to customize the visitor behavior.

fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)

This method can be overridden to customize the visitor behavior.

fn visit_method_kind(&mut self, n: &MethodKind)

This method can be overridden to customize the visitor behavior.

fn visit_method_prop(&mut self, n: &MethodProp)

This method can be overridden to customize the visitor behavior.

fn visit_module(&mut self, n: &Module)

This method can be overridden to customize the visitor behavior.

fn visit_module_decl(&mut self, n: &ModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_module_export_name(&mut self, n: &ModuleExportName)

This method can be overridden to customize the visitor behavior.

fn visit_module_item(&mut self, n: &ModuleItem)

This method can be overridden to customize the visitor behavior.

fn visit_module_items(&mut self, n: &[ModuleItem])

fn visit_named_export(&mut self, n: &NamedExport)

This method can be overridden to customize the visitor behavior.

fn visit_new_expr(&mut self, n: &NewExpr)

This method can be overridden to customize the visitor behavior.

fn visit_null(&mut self, n: &Null)

This method can be overridden to customize the visitor behavior.

fn visit_number(&mut self, n: &Number)

This method can be overridden to customize the visitor behavior.

fn visit_object_lit(&mut self, n: &ObjectLit)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat(&mut self, n: &ObjectPat)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])

fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)

fn visit_opt_atom(&mut self, n: Option<&Atom>)

fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)

fn visit_opt_call(&mut self, n: &OptCall)

This method can be overridden to customize the visitor behavior.

fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)

fn visit_opt_chain_base(&mut self, n: &OptChainBase)

This method can be overridden to customize the visitor behavior.

fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)

This method can be overridden to customize the visitor behavior.

fn visit_opt_expr(&mut self, n: Option<&Box<Expr>>)

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_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_module_items(&mut self, n: Option<&[ModuleItem]>)

fn visit_opt_object_lit(&mut self, n: Option<&Box<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>>)

fn visit_opt_str(&mut self, n: Option<&Box<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>>)

fn visit_opt_ts_type_ann(&mut self, n: Option<&Box<TsTypeAnn>>)

fn visit_opt_ts_type_param_decl(&mut self, n: Option<&Box<TsTypeParamDecl>>)

fn visit_opt_ts_type_param_instantiation( &mut self, n: Option<&Box<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)

This method can be overridden to customize the visitor behavior.

fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)

This method can be overridden to customize the visitor behavior.

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)

This method can be overridden to customize the visitor behavior.

fn visit_pat(&mut self, n: &Pat)

This method can be overridden to customize the visitor behavior.

fn visit_pats(&mut self, n: &[Pat])

fn visit_private_method(&mut self, n: &PrivateMethod)

This method can be overridden to customize the visitor behavior.

fn visit_private_name(&mut self, n: &PrivateName)

This method can be overridden to customize the visitor behavior.

fn visit_private_prop(&mut self, n: &PrivateProp)

This method can be overridden to customize the visitor behavior.

fn visit_program(&mut self, n: &Program)

This method can be overridden to customize the visitor behavior.

fn visit_prop(&mut self, n: &Prop)

This method can be overridden to customize the visitor behavior.

fn visit_prop_name(&mut self, n: &PropName)

This method can be overridden to customize the visitor behavior.

fn visit_prop_or_spread(&mut self, n: &PropOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])

fn visit_regex(&mut self, n: &Regex)

This method can be overridden to customize the visitor behavior.

fn visit_reserved_unused(&mut self, n: &ReservedUnused)

This method can be overridden to customize the visitor behavior.

fn visit_rest_pat(&mut self, n: &RestPat)

This method can be overridden to customize the visitor behavior.

fn visit_return_stmt(&mut self, n: &ReturnStmt)

This method can be overridden to customize the visitor behavior.

fn visit_script(&mut self, n: &Script)

This method can be overridden to customize the visitor behavior.

fn visit_seq_expr(&mut self, n: &SeqExpr)

This method can be overridden to customize the visitor behavior.

fn visit_setter_prop(&mut self, n: &SetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_span(&mut self, n: &Span)

fn visit_spread_element(&mut self, n: &SpreadElement)

This method can be overridden to customize the visitor behavior.

fn visit_static_block(&mut self, n: &StaticBlock)

This method can be overridden to customize the visitor behavior.

fn visit_stmt(&mut self, n: &Stmt)

This method can be overridden to customize the visitor behavior.

fn visit_stmts(&mut self, n: &[Stmt])

fn visit_str(&mut self, n: &Str)

This method can be overridden to customize the visitor behavior.

fn visit_super(&mut self, n: &Super)

This method can be overridden to customize the visitor behavior.

fn visit_super_prop(&mut self, n: &SuperProp)

This method can be overridden to customize the visitor behavior.

fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_switch_case(&mut self, n: &SwitchCase)

This method can be overridden to customize the visitor behavior.

fn visit_switch_cases(&mut self, n: &[SwitchCase])

fn visit_switch_stmt(&mut self, n: &SwitchStmt)

This method can be overridden to customize the visitor behavior.

fn visit_tagged_tpl(&mut self, n: &TaggedTpl)

This method can be overridden to customize the visitor behavior.

fn visit_this_expr(&mut self, n: &ThisExpr)

This method can be overridden to customize the visitor behavior.

fn visit_throw_stmt(&mut self, n: &ThrowStmt)

This method can be overridden to customize the visitor behavior.

fn visit_tpl(&mut self, n: &Tpl)

This method can be overridden to customize the visitor behavior.

fn visit_tpl_element(&mut self, n: &TplElement)

This method can be overridden to customize the visitor behavior.

fn visit_tpl_elements(&mut self, n: &[TplElement])

fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)

This method can be overridden to customize the visitor behavior.

fn visit_try_stmt(&mut self, n: &TryStmt)

This method can be overridden to customize the visitor behavior.

fn visit_ts_array_type(&mut self, n: &TsArrayType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_as_expr(&mut self, n: &TsAsExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_entity_name(&mut self, n: &TsEntityName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_member(&mut self, n: &TsEnumMember)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)

This method can be overridden to customize the visitor behavior.

fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])

fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)

This method can be overridden to customize the visitor behavior.

fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)

This method can be overridden to customize the visitor behavior.

fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])

fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_param(&mut self, n: &TsFnParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_fn_params(&mut self, n: &[TsFnParam])

fn visit_ts_fn_type(&mut self, n: &TsFnType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_import_type(&mut self, n: &TsImportType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_infer_type(&mut self, n: &TsInferType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_instantiation(&mut self, n: &TsInstantiation)

This method can be overridden to customize the visitor behavior.

fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)

This method can be overridden to customize the visitor behavior.

fn visit_ts_lit(&mut self, n: &TsLit)

This method can be overridden to customize the visitor behavior.

fn visit_ts_lit_type(&mut self, n: &TsLitType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_mapped_type(&mut self, n: &TsMappedType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_block(&mut self, n: &TsModuleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_name(&mut self, n: &TsModuleName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_module_ref(&mut self, n: &TsModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_optional_type(&mut self, n: &TsOptionalType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_param_prop(&mut self, n: &TsParamProp)

This method can be overridden to customize the visitor behavior.

fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)

This method can be overridden to customize the visitor behavior.

fn visit_ts_rest_type(&mut self, n: &TsRestType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_ts_this_type(&mut self, n: &TsThisType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)

This method can be overridden to customize the visitor behavior.

fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])

fn visit_ts_tuple_type(&mut self, n: &TsTupleType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type(&mut self, n: &TsType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_element(&mut self, n: &TsTypeElement)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])

fn visit_ts_type_lit(&mut self, n: &TsTypeLit)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param(&mut self, n: &TsTypeParam)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_params(&mut self, n: &[TsTypeParam])

fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_query(&mut self, n: &TsTypeQuery)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_ts_type_ref(&mut self, n: &TsTypeRef)

This method can be overridden to customize the visitor behavior.

fn visit_ts_types(&mut self, n: &[Box<TsType>])

fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)

This method can be overridden to customize the visitor behavior.

fn visit_ts_union_type(&mut self, n: &TsUnionType)

This method can be overridden to customize the visitor behavior.

fn visit_unary_expr(&mut self, n: &UnaryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_unary_op(&mut self, n: &UnaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_update_expr(&mut self, n: &UpdateExpr)

This method can be overridden to customize the visitor behavior.

fn visit_update_op(&mut self, n: &UpdateOp)

This method can be overridden to customize the visitor behavior.

fn visit_using_decl(&mut self, n: &UsingDecl)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl(&mut self, n: &VarDecl)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl_kind(&mut self, n: &VarDeclKind)

This method can be overridden to customize the visitor behavior.

fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_var_declarator(&mut self, n: &VarDeclarator)

This method can be overridden to customize the visitor behavior.

fn visit_var_declarators(&mut self, n: &[VarDeclarator])

fn visit_while_stmt(&mut self, n: &WhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_with_stmt(&mut self, n: &WithStmt)

This method can be overridden to customize the visitor behavior.

fn visit_yield_expr(&mut self, n: &YieldExpr)

This method can be overridden to customize the visitor behavior.

impl<A, B> VisitAll for Either<A, B>

where A: VisitAll, B: VisitAll,

fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)

This method can be overridden to customize the visitor behavior.

fn visit_alpha_value(&mut self, n: &AlphaValue)

This method can be overridden to customize the visitor behavior.

fn visit_an_plus_b(&mut self, n: &AnPlusB)

This method can be overridden to customize the visitor behavior.

fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)

This method can be overridden to customize the visitor behavior.

fn visit_angle(&mut self, n: &Angle)

This method can be overridden to customize the visitor behavior.

fn visit_angle_percentage(&mut self, n: &AnglePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_any_namespace(&mut self, n: &AnyNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule(&mut self, n: &AtRule)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule_name(&mut self, n: &AtRuleName)

This method can be overridden to customize the visitor behavior.

fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_atom(&mut self, n: &Atom)

fn visit_attribute_selector(&mut self, n: &AttributeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_matcher_value( &mut self, n: &AttributeSelectorMatcherValue )

fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)

This method can be overridden to customize the visitor behavior.

fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)

This method can be overridden to customize the visitor behavior.

fn visit_calc_operator(&mut self, n: &CalcOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product(&mut self, n: &CalcProduct)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_product_or_operators(&mut self, n: &[CalcProductOrOperator])

fn visit_calc_sum(&mut self, n: &CalcSum)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value(&mut self, n: &CalcValue)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_calc_value_or_operators(&mut self, n: &[CalcValueOrOperator])

fn visit_class_selector(&mut self, n: &ClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_cmyk_component(&mut self, n: &CmykComponent)

This method can be overridden to customize the visitor behavior.

fn visit_color(&mut self, n: &Color)

This method can be overridden to customize the visitor behavior.

fn visit_color_profile_name(&mut self, n: &ColorProfileName)

This method can be overridden to customize the visitor behavior.

fn visit_combinator(&mut self, n: &Combinator)

This method can be overridden to customize the visitor behavior.

fn visit_combinator_value(&mut self, n: &CombinatorValue)

fn visit_complex_selector(&mut self, n: &ComplexSelector)

This method can be overridden to customize the visitor behavior.

fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)

This method can be overridden to customize the visitor behavior.

fn visit_complex_selector_children_vec(&mut self, n: &[ComplexSelectorChildren])

fn visit_complex_selectors(&mut self, n: &[ComplexSelector])

fn visit_component_value(&mut self, n: &ComponentValue)

This method can be overridden to customize the visitor behavior.

fn visit_component_values(&mut self, n: &[ComponentValue])

fn visit_compound_selector(&mut self, n: &CompoundSelector)

This method can be overridden to customize the visitor behavior.

fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_compound_selectors(&mut self, n: &[CompoundSelector])

fn visit_container_condition(&mut self, n: &ContainerCondition)

This method can be overridden to customize the visitor behavior.

fn visit_container_name(&mut self, n: &ContainerName)

This method can be overridden to customize the visitor behavior.

fn visit_container_query(&mut self, n: &ContainerQuery)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_not(&mut self, n: &ContainerQueryNot)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_or(&mut self, n: &ContainerQueryOr)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_type(&mut self, n: &ContainerQueryType)

This method can be overridden to customize the visitor behavior.

fn visit_container_query_types(&mut self, n: &[ContainerQueryType])

fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)

This method can be overridden to customize the visitor behavior.

fn visit_custom_ident(&mut self, n: &CustomIdent)

This method can be overridden to customize the visitor behavior.

fn visit_custom_idents(&mut self, n: &[CustomIdent])

fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)

This method can be overridden to customize the visitor behavior.

fn visit_custom_property_name(&mut self, n: &CustomPropertyName)

This method can be overridden to customize the visitor behavior.

fn visit_dashed_ident(&mut self, n: &DashedIdent)

This method can be overridden to customize the visitor behavior.

fn visit_declaration(&mut self, n: &Declaration)

This method can be overridden to customize the visitor behavior.

fn visit_declaration_name(&mut self, n: &DeclarationName)

This method can be overridden to customize the visitor behavior.

fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)

This method can be overridden to customize the visitor behavior.

fn visit_delimiter(&mut self, n: &Delimiter)

This method can be overridden to customize the visitor behavior.

fn visit_delimiter_value(&mut self, n: &DelimiterValue)

This method can be overridden to customize the visitor behavior.

fn visit_dimension(&mut self, n: &Dimension)

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude(&mut self, n: &DocumentPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude_matching_function( &mut self, n: &DocumentPreludeMatchingFunction )

This method can be overridden to customize the visitor behavior.

fn visit_document_prelude_matching_functions( &mut self, n: &[DocumentPreludeMatchingFunction] )

fn visit_extension_name(&mut self, n: &ExtensionName)

This method can be overridden to customize the visitor behavior.

fn visit_family_name(&mut self, n: &FamilyName)

This method can be overridden to customize the visitor behavior.

fn visit_family_names(&mut self, n: &[FamilyName])

fn visit_flex(&mut self, n: &Flex)

This method can be overridden to customize the visitor behavior.

fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_complex_selectors(&mut self, n: &[ForgivingComplexSelector])

fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_relative_selector_list( &mut self, n: &ForgivingRelativeSelectorList )

This method can be overridden to customize the visitor behavior.

fn visit_forgiving_relative_selectors( &mut self, n: &[ForgivingRelativeSelector] )

fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_frequency(&mut self, n: &Frequency)

This method can be overridden to customize the visitor behavior.

fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_function(&mut self, n: &Function)

This method can be overridden to customize the visitor behavior.

fn visit_function_name(&mut self, n: &FunctionName)

This method can be overridden to customize the visitor behavior.

fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)

This method can be overridden to customize the visitor behavior.

fn visit_hex_color(&mut self, n: &HexColor)

This method can be overridden to customize the visitor behavior.

fn visit_hue(&mut self, n: &Hue)

This method can be overridden to customize the visitor behavior.

fn visit_i_32(&mut self, n: &i32)

fn visit_id_selector(&mut self, n: &IdSelector)

This method can be overridden to customize the visitor behavior.

fn visit_ident(&mut self, n: &Ident)

This method can be overridden to customize the visitor behavior.

fn visit_idents(&mut self, n: &[Ident])

fn visit_import_conditions(&mut self, n: &ImportConditions)

This method can be overridden to customize the visitor behavior.

fn visit_import_href(&mut self, n: &ImportHref)

This method can be overridden to customize the visitor behavior.

fn visit_import_layer_name(&mut self, n: &ImportLayerName)

This method can be overridden to customize the visitor behavior.

fn visit_import_prelude(&mut self, n: &ImportPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_important_flag(&mut self, n: &ImportantFlag)

This method can be overridden to customize the visitor behavior.

fn visit_integer(&mut self, n: &Integer)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_block(&mut self, n: &KeyframeBlock)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_keyframe_selectors(&mut self, n: &[KeyframeSelector])

fn visit_keyframes_name(&mut self, n: &KeyframesName)

This method can be overridden to customize the visitor behavior.

fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)

This method can be overridden to customize the visitor behavior.

fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)

This method can be overridden to customize the visitor behavior.

fn visit_layer_name(&mut self, n: &LayerName)

This method can be overridden to customize the visitor behavior.

fn visit_layer_name_list(&mut self, n: &LayerNameList)

This method can be overridden to customize the visitor behavior.

fn visit_layer_names(&mut self, n: &[LayerName])

fn visit_layer_prelude(&mut self, n: &LayerPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_length(&mut self, n: &Length)

This method can be overridden to customize the visitor behavior.

fn visit_length_percentage(&mut self, n: &LengthPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)

This method can be overridden to customize the visitor behavior.

fn visit_media_and(&mut self, n: &MediaAnd)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition(&mut self, n: &MediaCondition)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_all_types(&mut self, n: &[MediaConditionAllType])

fn visit_media_condition_type(&mut self, n: &MediaConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or_type( &mut self, n: &MediaConditionWithoutOrType )

This method can be overridden to customize the visitor behavior.

fn visit_media_condition_without_or_types( &mut self, n: &[MediaConditionWithoutOrType] )

fn visit_media_feature(&mut self, n: &MediaFeature)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_name(&mut self, n: &MediaFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_range_comparison( &mut self, n: &MediaFeatureRangeComparison )

fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)

This method can be overridden to customize the visitor behavior.

fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_media_in_parens(&mut self, n: &MediaInParens)

This method can be overridden to customize the visitor behavior.

fn visit_media_not(&mut self, n: &MediaNot)

This method can be overridden to customize the visitor behavior.

fn visit_media_or(&mut self, n: &MediaOr)

This method can be overridden to customize the visitor behavior.

fn visit_media_queries(&mut self, n: &[MediaQuery])

fn visit_media_query(&mut self, n: &MediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_media_query_list(&mut self, n: &MediaQueryList)

This method can be overridden to customize the visitor behavior.

fn visit_media_type(&mut self, n: &MediaType)

This method can be overridden to customize the visitor behavior.

fn visit_named_namespace(&mut self, n: &NamedNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_namespace(&mut self, n: &Namespace)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)

This method can be overridden to customize the visitor behavior.

fn visit_nesting_selector(&mut self, n: &NestingSelector)

This method can be overridden to customize the visitor behavior.

fn visit_number(&mut self, n: &Number)

This method can be overridden to customize the visitor behavior.

fn visit_opt_at_rule_prelude(&mut self, n: Option<&Box<AtRulePrelude>>)

fn visit_opt_atom(&mut self, n: Option<&Atom>)

fn visit_opt_attribute_selector_matcher( &mut self, n: Option<&AttributeSelectorMatcher> )

fn visit_opt_attribute_selector_modifier( &mut self, n: Option<&AttributeSelectorModifier> )

fn visit_opt_attribute_selector_value( &mut self, n: Option<&AttributeSelectorValue> )

fn visit_opt_combinator(&mut self, n: Option<&Combinator>)

fn visit_opt_container_name(&mut self, n: Option<&ContainerName>)

fn visit_opt_forgiving_selector_list( &mut self, n: Option<&ForgivingSelectorList> )

fn visit_opt_function(&mut self, n: Option<&Box<Function>>)

fn visit_opt_i_32(&mut self, n: Option<&i32>)

fn visit_opt_ident(&mut self, n: Option<&Ident>)

fn visit_opt_import_conditions(&mut self, n: Option<&Box<ImportConditions>>)

fn visit_opt_import_layer_name(&mut self, n: Option<&Box<ImportLayerName>>)

fn visit_opt_important_flag(&mut self, n: Option<&ImportantFlag>)

fn visit_opt_media_condition_type( &mut self, n: Option<&Box<MediaConditionType>> )

fn visit_opt_media_query_list(&mut self, n: Option<&Box<MediaQueryList>>)

fn visit_opt_media_type(&mut self, n: Option<&MediaType>)

fn visit_opt_namespace(&mut self, n: Option<&Namespace>)

fn visit_opt_namespace_prefix(&mut self, n: Option<&NamespacePrefix>)

fn visit_opt_nesting_selector(&mut self, n: Option<&NestingSelector>)

fn visit_opt_number(&mut self, n: Option<&Number>)

fn visit_opt_page_selector_pseudos(&mut self, n: Option<&[PageSelectorPseudo]>)

fn visit_opt_page_selector_type(&mut self, n: Option<&PageSelectorType>)

fn visit_opt_pseudo_class_selector_children_vec( &mut self, n: Option<&[PseudoClassSelectorChildren]> )

fn visit_opt_pseudo_element_selector_children_vec( &mut self, n: Option<&[PseudoElementSelectorChildren]> )

fn visit_opt_simple_block(&mut self, n: Option<&SimpleBlock>)

fn visit_opt_type_selector(&mut self, n: Option<&Box<TypeSelector>>)

fn visit_opt_url_modifiers(&mut self, n: Option<&[UrlModifier]>)

fn visit_opt_url_value(&mut self, n: Option<&Box<UrlValue>>)

fn visit_page_selector(&mut self, n: &PageSelector)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_list(&mut self, n: &PageSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)

This method can be overridden to customize the visitor behavior.

fn visit_page_selector_pseudos(&mut self, n: &[PageSelectorPseudo])

fn visit_page_selector_type(&mut self, n: &PageSelectorType)

This method can be overridden to customize the visitor behavior.

fn visit_page_selectors(&mut self, n: &[PageSelector])

fn visit_percentage(&mut self, n: &Percentage)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector_children( &mut self, n: &PseudoClassSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_class_selector_children_vec( &mut self, n: &[PseudoClassSelectorChildren] )

fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_element_selector_children( &mut self, n: &PseudoElementSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_pseudo_element_selector_children_vec( &mut self, n: &[PseudoElementSelectorChildren] )

fn visit_qualified_rule(&mut self, n: &QualifiedRule)

This method can be overridden to customize the visitor behavior.

fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_query_in_parens(&mut self, n: &QueryInParens)

This method can be overridden to customize the visitor behavior.

fn visit_ratio(&mut self, n: &Ratio)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selector(&mut self, n: &RelativeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_relative_selectors(&mut self, n: &[RelativeSelector])

fn visit_resolution(&mut self, n: &Resolution)

This method can be overridden to customize the visitor behavior.

fn visit_rule(&mut self, n: &Rule)

This method can be overridden to customize the visitor behavior.

fn visit_rules(&mut self, n: &[Rule])

fn visit_scope_range(&mut self, n: &ScopeRange)

This method can be overridden to customize the visitor behavior.

fn visit_selector_list(&mut self, n: &SelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)

This method can be overridden to customize the visitor behavior.

fn visit_simple_block(&mut self, n: &SimpleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature(&mut self, n: &SizeFeature)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_name(&mut self, n: &SizeFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range_comparison( &mut self, n: &SizeFeatureRangeComparison )

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)

This method can be overridden to customize the visitor behavior.

fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_span(&mut self, n: &Span)

fn visit_str(&mut self, n: &Str)

This method can be overridden to customize the visitor behavior.

fn visit_style_block(&mut self, n: &StyleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_stylesheet(&mut self, n: &Stylesheet)

This method can be overridden to customize the visitor behavior.

fn visit_subclass_selector(&mut self, n: &SubclassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_subclass_selectors(&mut self, n: &[SubclassSelector])

fn visit_supports_and(&mut self, n: &SupportsAnd)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition(&mut self, n: &SupportsCondition)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_supports_condition_types(&mut self, n: &[SupportsConditionType])

fn visit_supports_feature(&mut self, n: &SupportsFeature)

This method can be overridden to customize the visitor behavior.

fn visit_supports_in_parens(&mut self, n: &SupportsInParens)

This method can be overridden to customize the visitor behavior.

fn visit_supports_not(&mut self, n: &SupportsNot)

This method can be overridden to customize the visitor behavior.

fn visit_supports_or(&mut self, n: &SupportsOr)

This method can be overridden to customize the visitor behavior.

fn visit_tag_name_selector(&mut self, n: &TagNameSelector)

This method can be overridden to customize the visitor behavior.

fn visit_time(&mut self, n: &Time)

This method can be overridden to customize the visitor behavior.

fn visit_time_percentage(&mut self, n: &TimePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_token(&mut self, n: &Token)

fn visit_token_and_span(&mut self, n: &TokenAndSpan)

This method can be overridden to customize the visitor behavior.

fn visit_type_selector(&mut self, n: &TypeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_unicode_range(&mut self, n: &UnicodeRange)

This method can be overridden to customize the visitor behavior.

fn visit_universal_selector(&mut self, n: &UniversalSelector)

This method can be overridden to customize the visitor behavior.

fn visit_unknown_dimension(&mut self, n: &UnknownDimension)

This method can be overridden to customize the visitor behavior.

fn visit_url(&mut self, n: &Url)

This method can be overridden to customize the visitor behavior.

fn visit_url_modifier(&mut self, n: &UrlModifier)

This method can be overridden to customize the visitor behavior.

fn visit_url_modifiers(&mut self, n: &[UrlModifier])

fn visit_url_value(&mut self, n: &UrlValue)

This method can be overridden to customize the visitor behavior.

fn visit_url_value_raw(&mut self, n: &UrlValueRaw)

This method can be overridden to customize the visitor behavior.

fn visit_wq_name(&mut self, n: &WqName)

This method can be overridden to customize the visitor behavior.

impl<A, B> VisitMut for Either<A, B>

where A: VisitMut, B: VisitMut,

fn visit_mut_accessibility(&mut self, n: &mut Accessibility)

This method can be overridden to customize the visitor behavior.

fn visit_mut_array_lit(&mut self, n: &mut ArrayLit)

This method can be overridden to customize the visitor behavior.

fn visit_mut_array_pat(&mut self, n: &mut ArrayPat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_op(&mut self, n: &mut AssignOp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_pat(&mut self, n: &mut AssignPat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_prop(&mut self, n: &mut AssignProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_target(&mut self, n: &mut AssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_mut_assign_target_pat(&mut self, n: &mut AssignTargetPat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_atom(&mut self, n: &mut Atom)

fn visit_mut_auto_accessor(&mut self, n: &mut AutoAccessor)

This method can be overridden to customize the visitor behavior.

fn visit_mut_await_expr(&mut self, n: &mut AwaitExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_big_int(&mut self, n: &mut BigInt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_big_int_value(&mut self, n: &mut BigInt)

fn visit_mut_bin_expr(&mut self, n: &mut BinExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_binary_op(&mut self, n: &mut BinaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_binding_ident(&mut self, n: &mut BindingIdent)

This method can be overridden to customize the visitor behavior.

fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_block_stmt_or_expr(&mut self, n: &mut BlockStmtOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_bool(&mut self, n: &mut Bool)

This method can be overridden to customize the visitor behavior.

fn visit_mut_break_stmt(&mut self, n: &mut BreakStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_call_expr(&mut self, n: &mut CallExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_callee(&mut self, n: &mut Callee)

This method can be overridden to customize the visitor behavior.

fn visit_mut_catch_clause(&mut self, n: &mut CatchClause)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class(&mut self, n: &mut Class)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class_decl(&mut self, n: &mut ClassDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class_expr(&mut self, n: &mut ClassExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class_member(&mut self, n: &mut ClassMember)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class_members(&mut self, n: &mut Vec<ClassMember>)

fn visit_mut_class_method(&mut self, n: &mut ClassMethod)

This method can be overridden to customize the visitor behavior.

fn visit_mut_class_prop(&mut self, n: &mut ClassProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_computed_prop_name(&mut self, n: &mut ComputedPropName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_cond_expr(&mut self, n: &mut CondExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_constructor(&mut self, n: &mut Constructor)

This method can be overridden to customize the visitor behavior.

fn visit_mut_continue_stmt(&mut self, n: &mut ContinueStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_debugger_stmt(&mut self, n: &mut DebuggerStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_decl(&mut self, n: &mut Decl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_decorator(&mut self, n: &mut Decorator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_decorators(&mut self, n: &mut Vec<Decorator>)

fn visit_mut_default_decl(&mut self, n: &mut DefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_do_while_stmt(&mut self, n: &mut DoWhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_empty_stmt(&mut self, n: &mut EmptyStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_all(&mut self, n: &mut ExportAll)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_decl(&mut self, n: &mut ExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_default_specifier(&mut self, n: &mut ExportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_namespace_specifier( &mut self, n: &mut ExportNamespaceSpecifier )

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_specifier(&mut self, n: &mut ExportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_export_specifiers(&mut self, n: &mut Vec<ExportSpecifier>)

fn visit_mut_expr(&mut self, n: &mut Expr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_expr_or_spread(&mut self, n: &mut ExprOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_mut_expr_or_spreads(&mut self, n: &mut Vec<ExprOrSpread>)

fn visit_mut_expr_stmt(&mut self, n: &mut ExprStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_exprs(&mut self, n: &mut Vec<Box<Expr>>)

fn visit_mut_fn_decl(&mut self, n: &mut FnDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_fn_expr(&mut self, n: &mut FnExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_for_head(&mut self, n: &mut ForHead)

This method can be overridden to customize the visitor behavior.

fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_for_stmt(&mut self, n: &mut ForStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_function(&mut self, n: &mut Function)

This method can be overridden to customize the visitor behavior.

fn visit_mut_getter_prop(&mut self, n: &mut GetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ident(&mut self, n: &mut Ident)

This method can be overridden to customize the visitor behavior.

fn visit_mut_if_stmt(&mut self, n: &mut IfStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import(&mut self, n: &mut Import)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_decl(&mut self, n: &mut ImportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_default_specifier(&mut self, n: &mut ImportDefaultSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_named_specifier(&mut self, n: &mut ImportNamedSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_phase(&mut self, n: &mut ImportPhase)

fn visit_mut_import_specifier(&mut self, n: &mut ImportSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_specifiers(&mut self, n: &mut Vec<ImportSpecifier>)

fn visit_mut_import_star_as_specifier(&mut self, n: &mut ImportStarAsSpecifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_invalid(&mut self, n: &mut Invalid)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_attr(&mut self, n: &mut JSXAttr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_attr_name(&mut self, n: &mut JSXAttrName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_attr_or_spread(&mut self, n: &mut JSXAttrOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_attr_or_spreads(&mut self, n: &mut Vec<JSXAttrOrSpread>)

fn visit_mut_jsx_attr_value(&mut self, n: &mut JSXAttrValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_closing_element(&mut self, n: &mut JSXClosingElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_closing_fragment(&mut self, n: &mut JSXClosingFragment)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_element(&mut self, n: &mut JSXElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_element_child(&mut self, n: &mut JSXElementChild)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_element_children(&mut self, n: &mut Vec<JSXElementChild>)

fn visit_mut_jsx_element_name(&mut self, n: &mut JSXElementName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_empty_expr(&mut self, n: &mut JSXEmptyExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_expr(&mut self, n: &mut JSXExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_expr_container(&mut self, n: &mut JSXExprContainer)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_fragment(&mut self, n: &mut JSXFragment)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_member_expr(&mut self, n: &mut JSXMemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_namespaced_name(&mut self, n: &mut JSXNamespacedName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_object(&mut self, n: &mut JSXObject)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_opening_element(&mut self, n: &mut JSXOpeningElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_opening_fragment(&mut self, n: &mut JSXOpeningFragment)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_spread_child(&mut self, n: &mut JSXSpreadChild)

This method can be overridden to customize the visitor behavior.

fn visit_mut_jsx_text(&mut self, n: &mut JSXText)

This method can be overridden to customize the visitor behavior.

fn visit_mut_key(&mut self, n: &mut Key)

This method can be overridden to customize the visitor behavior.

fn visit_mut_key_value_pat_prop(&mut self, n: &mut KeyValuePatProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_key_value_prop(&mut self, n: &mut KeyValueProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_lit(&mut self, n: &mut Lit)

This method can be overridden to customize the visitor behavior.

fn visit_mut_member_expr(&mut self, n: &mut MemberExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_member_prop(&mut self, n: &mut MemberProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_meta_prop_expr(&mut self, n: &mut MetaPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_meta_prop_kind(&mut self, n: &mut MetaPropKind)

This method can be overridden to customize the visitor behavior.

fn visit_mut_method_kind(&mut self, n: &mut MethodKind)

This method can be overridden to customize the visitor behavior.

fn visit_mut_method_prop(&mut self, n: &mut MethodProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_module(&mut self, n: &mut Module)

This method can be overridden to customize the visitor behavior.

fn visit_mut_module_decl(&mut self, n: &mut ModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_module_export_name(&mut self, n: &mut ModuleExportName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_module_item(&mut self, n: &mut ModuleItem)

This method can be overridden to customize the visitor behavior.

fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>)

fn visit_mut_named_export(&mut self, n: &mut NamedExport)

This method can be overridden to customize the visitor behavior.

fn visit_mut_new_expr(&mut self, n: &mut NewExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_null(&mut self, n: &mut Null)

This method can be overridden to customize the visitor behavior.

fn visit_mut_number(&mut self, n: &mut Number)

This method can be overridden to customize the visitor behavior.

fn visit_mut_object_lit(&mut self, n: &mut ObjectLit)

This method can be overridden to customize the visitor behavior.

fn visit_mut_object_pat(&mut self, n: &mut ObjectPat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_object_pat_props(&mut self, n: &mut Vec<ObjectPatProp>)

fn visit_mut_opt_accessibility(&mut self, n: &mut Option<Accessibility>)

fn visit_mut_opt_atom(&mut self, n: &mut Option<Atom>)

fn visit_mut_opt_block_stmt(&mut self, n: &mut Option<BlockStmt>)

fn visit_mut_opt_call(&mut self, n: &mut OptCall)

This method can be overridden to customize the visitor behavior.

fn visit_mut_opt_catch_clause(&mut self, n: &mut Option<CatchClause>)

fn visit_mut_opt_chain_base(&mut self, n: &mut OptChainBase)

This method can be overridden to customize the visitor behavior.

fn visit_mut_opt_chain_expr(&mut self, n: &mut OptChainExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_opt_expr(&mut self, n: &mut Option<Box<Expr>>)

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>>)

fn visit_mut_opt_ident(&mut self, n: &mut Option<Ident>)

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_module_items(&mut self, n: &mut Option<Vec<ModuleItem>>)

fn visit_mut_opt_object_lit(&mut self, n: &mut Option<Box<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>>)

fn visit_mut_opt_str(&mut self, n: &mut Option<Box<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>>)

fn visit_mut_opt_ts_type_ann(&mut self, n: &mut Option<Box<TsTypeAnn>>)

fn visit_mut_opt_ts_type_param_decl( &mut self, n: &mut Option<Box<TsTypeParamDecl>> )

fn visit_mut_opt_ts_type_param_instantiation( &mut self, n: &mut Option<Box<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>> )

fn visit_mut_opt_vec_pats(&mut self, n: &mut Vec<Option<Pat>>)

fn visit_mut_param(&mut self, n: &mut Param)

This method can be overridden to customize the visitor behavior.

fn visit_mut_param_or_ts_param_prop(&mut self, n: &mut ParamOrTsParamProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_param_or_ts_param_props(&mut self, n: &mut Vec<ParamOrTsParamProp>)

fn visit_mut_params(&mut self, n: &mut Vec<Param>)

fn visit_mut_paren_expr(&mut self, n: &mut ParenExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_pat(&mut self, n: &mut Pat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_pats(&mut self, n: &mut Vec<Pat>)

fn visit_mut_private_method(&mut self, n: &mut PrivateMethod)

This method can be overridden to customize the visitor behavior.

fn visit_mut_private_name(&mut self, n: &mut PrivateName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_private_prop(&mut self, n: &mut PrivateProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_program(&mut self, n: &mut Program)

This method can be overridden to customize the visitor behavior.

fn visit_mut_prop(&mut self, n: &mut Prop)

This method can be overridden to customize the visitor behavior.

fn visit_mut_prop_name(&mut self, n: &mut PropName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_prop_or_spread(&mut self, n: &mut PropOrSpread)

This method can be overridden to customize the visitor behavior.

fn visit_mut_prop_or_spreads(&mut self, n: &mut Vec<PropOrSpread>)

fn visit_mut_regex(&mut self, n: &mut Regex)

This method can be overridden to customize the visitor behavior.

fn visit_mut_reserved_unused(&mut self, n: &mut ReservedUnused)

This method can be overridden to customize the visitor behavior.

fn visit_mut_rest_pat(&mut self, n: &mut RestPat)

This method can be overridden to customize the visitor behavior.

fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_script(&mut self, n: &mut Script)

This method can be overridden to customize the visitor behavior.

fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_setter_prop(&mut self, n: &mut SetterProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_simple_assign_target(&mut self, n: &mut SimpleAssignTarget)

This method can be overridden to customize the visitor behavior.

fn visit_mut_span(&mut self, n: &mut Span)

fn visit_mut_spread_element(&mut self, n: &mut SpreadElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_static_block(&mut self, n: &mut StaticBlock)

This method can be overridden to customize the visitor behavior.

fn visit_mut_stmt(&mut self, n: &mut Stmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>)

fn visit_mut_str(&mut self, n: &mut Str)

This method can be overridden to customize the visitor behavior.

fn visit_mut_super(&mut self, n: &mut Super)

This method can be overridden to customize the visitor behavior.

fn visit_mut_super_prop(&mut self, n: &mut SuperProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_super_prop_expr(&mut self, n: &mut SuperPropExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_switch_case(&mut self, n: &mut SwitchCase)

This method can be overridden to customize the visitor behavior.

fn visit_mut_switch_cases(&mut self, n: &mut Vec<SwitchCase>)

fn visit_mut_switch_stmt(&mut self, n: &mut SwitchStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_this_expr(&mut self, n: &mut ThisExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_throw_stmt(&mut self, n: &mut ThrowStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_tpl(&mut self, n: &mut Tpl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_tpl_element(&mut self, n: &mut TplElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_tpl_elements(&mut self, n: &mut Vec<TplElement>)

fn visit_mut_true_plus_minus(&mut self, n: &mut TruePlusMinus)

This method can be overridden to customize the visitor behavior.

fn visit_mut_try_stmt(&mut self, n: &mut TryStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_array_type(&mut self, n: &mut TsArrayType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_as_expr(&mut self, n: &mut TsAsExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_call_signature_decl(&mut self, n: &mut TsCallSignatureDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_conditional_type(&mut self, n: &mut TsConditionalType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_const_assertion(&mut self, n: &mut TsConstAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_construct_signature_decl( &mut self, n: &mut TsConstructSignatureDecl )

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_constructor_type(&mut self, n: &mut TsConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_entity_name(&mut self, n: &mut TsEntityName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_enum_decl(&mut self, n: &mut TsEnumDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_enum_member(&mut self, n: &mut TsEnumMember)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_enum_member_id(&mut self, n: &mut TsEnumMemberId)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_enum_members(&mut self, n: &mut Vec<TsEnumMember>)

fn visit_mut_ts_export_assignment(&mut self, n: &mut TsExportAssignment)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_expr_with_type_args(&mut self, n: &mut TsExprWithTypeArgs)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_expr_with_type_args_vec( &mut self, n: &mut Vec<TsExprWithTypeArgs> )

fn visit_mut_ts_external_module_ref(&mut self, n: &mut TsExternalModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_fn_or_constructor_type(&mut self, n: &mut TsFnOrConstructorType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_fn_param(&mut self, n: &mut TsFnParam)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_fn_params(&mut self, n: &mut Vec<TsFnParam>)

fn visit_mut_ts_fn_type(&mut self, n: &mut TsFnType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_getter_signature(&mut self, n: &mut TsGetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_import_equals_decl(&mut self, n: &mut TsImportEqualsDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_import_type(&mut self, n: &mut TsImportType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_index_signature(&mut self, n: &mut TsIndexSignature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_indexed_access_type(&mut self, n: &mut TsIndexedAccessType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_infer_type(&mut self, n: &mut TsInferType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_instantiation(&mut self, n: &mut TsInstantiation)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_interface_body(&mut self, n: &mut TsInterfaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_intersection_type(&mut self, n: &mut TsIntersectionType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_keyword_type(&mut self, n: &mut TsKeywordType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_keyword_type_kind(&mut self, n: &mut TsKeywordTypeKind)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_lit(&mut self, n: &mut TsLit)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_lit_type(&mut self, n: &mut TsLitType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_mapped_type(&mut self, n: &mut TsMappedType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_method_signature(&mut self, n: &mut TsMethodSignature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_module_block(&mut self, n: &mut TsModuleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_module_decl(&mut self, n: &mut TsModuleDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_module_name(&mut self, n: &mut TsModuleName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_module_ref(&mut self, n: &mut TsModuleRef)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_namespace_body(&mut self, n: &mut TsNamespaceBody)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_namespace_decl(&mut self, n: &mut TsNamespaceDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_namespace_export_decl(&mut self, n: &mut TsNamespaceExportDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_non_null_expr(&mut self, n: &mut TsNonNullExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_optional_type(&mut self, n: &mut TsOptionalType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_param_prop(&mut self, n: &mut TsParamProp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_param_prop_param(&mut self, n: &mut TsParamPropParam)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_parenthesized_type(&mut self, n: &mut TsParenthesizedType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_property_signature(&mut self, n: &mut TsPropertySignature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_qualified_name(&mut self, n: &mut TsQualifiedName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_rest_type(&mut self, n: &mut TsRestType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_satisfies_expr(&mut self, n: &mut TsSatisfiesExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_setter_signature(&mut self, n: &mut TsSetterSignature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_this_type(&mut self, n: &mut TsThisType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_this_type_or_ident(&mut self, n: &mut TsThisTypeOrIdent)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_tpl_lit_type(&mut self, n: &mut TsTplLitType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_tuple_element(&mut self, n: &mut TsTupleElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_tuple_elements(&mut self, n: &mut Vec<TsTupleElement>)

fn visit_mut_ts_tuple_type(&mut self, n: &mut TsTupleType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type(&mut self, n: &mut TsType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_alias_decl(&mut self, n: &mut TsTypeAliasDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_ann(&mut self, n: &mut TsTypeAnn)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_assertion(&mut self, n: &mut TsTypeAssertion)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_element(&mut self, n: &mut TsTypeElement)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_elements(&mut self, n: &mut Vec<TsTypeElement>)

fn visit_mut_ts_type_lit(&mut self, n: &mut TsTypeLit)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_operator(&mut self, n: &mut TsTypeOperator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_operator_op(&mut self, n: &mut TsTypeOperatorOp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_param(&mut self, n: &mut TsTypeParam)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_param_decl(&mut self, n: &mut TsTypeParamDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_param_instantiation( &mut self, n: &mut TsTypeParamInstantiation )

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_params(&mut self, n: &mut Vec<TsTypeParam>)

fn visit_mut_ts_type_predicate(&mut self, n: &mut TsTypePredicate)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_query(&mut self, n: &mut TsTypeQuery)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_query_expr(&mut self, n: &mut TsTypeQueryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_type_ref(&mut self, n: &mut TsTypeRef)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_types(&mut self, n: &mut Vec<Box<TsType>>)

fn visit_mut_ts_union_or_intersection_type( &mut self, n: &mut TsUnionOrIntersectionType )

This method can be overridden to customize the visitor behavior.

fn visit_mut_ts_union_type(&mut self, n: &mut TsUnionType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_unary_op(&mut self, n: &mut UnaryOp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_update_op(&mut self, n: &mut UpdateOp)

This method can be overridden to customize the visitor behavior.

fn visit_mut_using_decl(&mut self, n: &mut UsingDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_var_decl(&mut self, n: &mut VarDecl)

This method can be overridden to customize the visitor behavior.

fn visit_mut_var_decl_kind(&mut self, n: &mut VarDeclKind)

This method can be overridden to customize the visitor behavior.

fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_var_declarators(&mut self, n: &mut Vec<VarDeclarator>)

fn visit_mut_while_stmt(&mut self, n: &mut WhileStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_with_stmt(&mut self, n: &mut WithStmt)

This method can be overridden to customize the visitor behavior.

fn visit_mut_yield_expr(&mut self, n: &mut YieldExpr)

This method can be overridden to customize the visitor behavior.

impl<A, B> VisitMut for Either<A, B>

where A: VisitMut, B: VisitMut,

fn visit_mut_absolute_color_base(&mut self, n: &mut AbsoluteColorBase)

This method can be overridden to customize the visitor behavior.

fn visit_mut_alpha_value(&mut self, n: &mut AlphaValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_an_plus_b(&mut self, n: &mut AnPlusB)

This method can be overridden to customize the visitor behavior.

fn visit_mut_an_plus_b_notation(&mut self, n: &mut AnPlusBNotation)

This method can be overridden to customize the visitor behavior.

fn visit_mut_angle(&mut self, n: &mut Angle)

This method can be overridden to customize the visitor behavior.

fn visit_mut_angle_percentage(&mut self, n: &mut AnglePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_mut_any_namespace(&mut self, n: &mut AnyNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_mut_at_rule(&mut self, n: &mut AtRule)

This method can be overridden to customize the visitor behavior.

fn visit_mut_at_rule_name(&mut self, n: &mut AtRuleName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_at_rule_prelude(&mut self, n: &mut AtRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_atom(&mut self, n: &mut Atom)

fn visit_mut_attribute_selector(&mut self, n: &mut AttributeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_attribute_selector_matcher( &mut self, n: &mut AttributeSelectorMatcher )

This method can be overridden to customize the visitor behavior.

fn visit_mut_attribute_selector_matcher_value( &mut self, n: &mut AttributeSelectorMatcherValue )

fn visit_mut_attribute_selector_modifier( &mut self, n: &mut AttributeSelectorModifier )

This method can be overridden to customize the visitor behavior.

fn visit_mut_attribute_selector_value(&mut self, n: &mut AttributeSelectorValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_operator(&mut self, n: &mut CalcOperator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_operator_type(&mut self, n: &mut CalcOperatorType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_product(&mut self, n: &mut CalcProduct)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_product_or_operator(&mut self, n: &mut CalcProductOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_product_or_operators( &mut self, n: &mut Vec<CalcProductOrOperator> )

fn visit_mut_calc_sum(&mut self, n: &mut CalcSum)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_value(&mut self, n: &mut CalcValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_value_or_operator(&mut self, n: &mut CalcValueOrOperator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_calc_value_or_operators( &mut self, n: &mut Vec<CalcValueOrOperator> )

fn visit_mut_class_selector(&mut self, n: &mut ClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_cmyk_component(&mut self, n: &mut CmykComponent)

This method can be overridden to customize the visitor behavior.

fn visit_mut_color(&mut self, n: &mut Color)

This method can be overridden to customize the visitor behavior.

fn visit_mut_color_profile_name(&mut self, n: &mut ColorProfileName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_combinator(&mut self, n: &mut Combinator)

This method can be overridden to customize the visitor behavior.

fn visit_mut_combinator_value(&mut self, n: &mut CombinatorValue)

fn visit_mut_complex_selector(&mut self, n: &mut ComplexSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_complex_selector_children( &mut self, n: &mut ComplexSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_mut_complex_selector_children_vec( &mut self, n: &mut Vec<ComplexSelectorChildren> )

fn visit_mut_complex_selectors(&mut self, n: &mut Vec<ComplexSelector>)

fn visit_mut_component_value(&mut self, n: &mut ComponentValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_component_values(&mut self, n: &mut Vec<ComponentValue>)

fn visit_mut_compound_selector(&mut self, n: &mut CompoundSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_compound_selector_list(&mut self, n: &mut CompoundSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_compound_selectors(&mut self, n: &mut Vec<CompoundSelector>)

fn visit_mut_container_condition(&mut self, n: &mut ContainerCondition)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_name(&mut self, n: &mut ContainerName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query(&mut self, n: &mut ContainerQuery)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query_and(&mut self, n: &mut ContainerQueryAnd)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query_not(&mut self, n: &mut ContainerQueryNot)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query_or(&mut self, n: &mut ContainerQueryOr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query_type(&mut self, n: &mut ContainerQueryType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_container_query_types(&mut self, n: &mut Vec<ContainerQueryType>)

fn visit_mut_custom_highlight_name(&mut self, n: &mut CustomHighlightName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_custom_ident(&mut self, n: &mut CustomIdent)

This method can be overridden to customize the visitor behavior.

fn visit_mut_custom_idents(&mut self, n: &mut Vec<CustomIdent>)

fn visit_mut_custom_media_query(&mut self, n: &mut CustomMediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_mut_custom_media_query_media_type( &mut self, n: &mut CustomMediaQueryMediaType )

This method can be overridden to customize the visitor behavior.

fn visit_mut_custom_property_name(&mut self, n: &mut CustomPropertyName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_dashed_ident(&mut self, n: &mut DashedIdent)

This method can be overridden to customize the visitor behavior.

fn visit_mut_declaration(&mut self, n: &mut Declaration)

This method can be overridden to customize the visitor behavior.

fn visit_mut_declaration_name(&mut self, n: &mut DeclarationName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_declaration_or_at_rule(&mut self, n: &mut DeclarationOrAtRule)

This method can be overridden to customize the visitor behavior.

fn visit_mut_delimiter(&mut self, n: &mut Delimiter)

This method can be overridden to customize the visitor behavior.

fn visit_mut_delimiter_value(&mut self, n: &mut DelimiterValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_dimension(&mut self, n: &mut Dimension)

This method can be overridden to customize the visitor behavior.

fn visit_mut_document_prelude(&mut self, n: &mut DocumentPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_document_prelude_matching_function( &mut self, n: &mut DocumentPreludeMatchingFunction )

This method can be overridden to customize the visitor behavior.

fn visit_mut_document_prelude_matching_functions( &mut self, n: &mut Vec<DocumentPreludeMatchingFunction> )

fn visit_mut_extension_name(&mut self, n: &mut ExtensionName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_family_name(&mut self, n: &mut FamilyName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_family_names(&mut self, n: &mut Vec<FamilyName>)

fn visit_mut_flex(&mut self, n: &mut Flex)

This method can be overridden to customize the visitor behavior.

fn visit_mut_font_feature_values_prelude( &mut self, n: &mut FontFeatureValuesPrelude )

This method can be overridden to customize the visitor behavior.

fn visit_mut_forgiving_complex_selector( &mut self, n: &mut ForgivingComplexSelector )

This method can be overridden to customize the visitor behavior.

fn visit_mut_forgiving_complex_selectors( &mut self, n: &mut Vec<ForgivingComplexSelector> )

fn visit_mut_forgiving_relative_selector( &mut self, n: &mut ForgivingRelativeSelector )

This method can be overridden to customize the visitor behavior.

fn visit_mut_forgiving_relative_selector_list( &mut self, n: &mut ForgivingRelativeSelectorList )

This method can be overridden to customize the visitor behavior.

fn visit_mut_forgiving_relative_selectors( &mut self, n: &mut Vec<ForgivingRelativeSelector> )

fn visit_mut_forgiving_selector_list(&mut self, n: &mut ForgivingSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_frequency(&mut self, n: &mut Frequency)

This method can be overridden to customize the visitor behavior.

fn visit_mut_frequency_percentage(&mut self, n: &mut FrequencyPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_mut_function(&mut self, n: &mut Function)

This method can be overridden to customize the visitor behavior.

fn visit_mut_function_name(&mut self, n: &mut FunctionName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_general_enclosed(&mut self, n: &mut GeneralEnclosed)

This method can be overridden to customize the visitor behavior.

fn visit_mut_hex_color(&mut self, n: &mut HexColor)

This method can be overridden to customize the visitor behavior.

fn visit_mut_hue(&mut self, n: &mut Hue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_i_32(&mut self, n: &mut i32)

fn visit_mut_id_selector(&mut self, n: &mut IdSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ident(&mut self, n: &mut Ident)

This method can be overridden to customize the visitor behavior.

fn visit_mut_idents(&mut self, n: &mut Vec<Ident>)

fn visit_mut_import_conditions(&mut self, n: &mut ImportConditions)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_href(&mut self, n: &mut ImportHref)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_layer_name(&mut self, n: &mut ImportLayerName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_import_prelude(&mut self, n: &mut ImportPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_important_flag(&mut self, n: &mut ImportantFlag)

This method can be overridden to customize the visitor behavior.

fn visit_mut_integer(&mut self, n: &mut Integer)

This method can be overridden to customize the visitor behavior.

fn visit_mut_keyframe_block(&mut self, n: &mut KeyframeBlock)

This method can be overridden to customize the visitor behavior.

fn visit_mut_keyframe_selector(&mut self, n: &mut KeyframeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_keyframe_selectors(&mut self, n: &mut Vec<KeyframeSelector>)

fn visit_mut_keyframes_name(&mut self, n: &mut KeyframesName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_keyframes_pseudo_function( &mut self, n: &mut KeyframesPseudoFunction )

This method can be overridden to customize the visitor behavior.

fn visit_mut_keyframes_pseudo_prefix(&mut self, n: &mut KeyframesPseudoPrefix)

This method can be overridden to customize the visitor behavior.

fn visit_mut_layer_name(&mut self, n: &mut LayerName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_layer_name_list(&mut self, n: &mut LayerNameList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_layer_names(&mut self, n: &mut Vec<LayerName>)

fn visit_mut_layer_prelude(&mut self, n: &mut LayerPrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_length(&mut self, n: &mut Length)

This method can be overridden to customize the visitor behavior.

fn visit_mut_length_percentage(&mut self, n: &mut LengthPercentage)

This method can be overridden to customize the visitor behavior.

fn visit_mut_list_of_component_values(&mut self, n: &mut ListOfComponentValues)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_and(&mut self, n: &mut MediaAnd)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition(&mut self, n: &mut MediaCondition)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition_all_type(&mut self, n: &mut MediaConditionAllType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition_all_types( &mut self, n: &mut Vec<MediaConditionAllType> )

fn visit_mut_media_condition_type(&mut self, n: &mut MediaConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition_without_or( &mut self, n: &mut MediaConditionWithoutOr )

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition_without_or_type( &mut self, n: &mut MediaConditionWithoutOrType )

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_condition_without_or_types( &mut self, n: &mut Vec<MediaConditionWithoutOrType> )

fn visit_mut_media_feature(&mut self, n: &mut MediaFeature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_boolean(&mut self, n: &mut MediaFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_name(&mut self, n: &mut MediaFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_plain(&mut self, n: &mut MediaFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_range(&mut self, n: &mut MediaFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_range_comparison( &mut self, n: &mut MediaFeatureRangeComparison )

fn visit_mut_media_feature_range_interval( &mut self, n: &mut MediaFeatureRangeInterval )

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_feature_value(&mut self, n: &mut MediaFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_in_parens(&mut self, n: &mut MediaInParens)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_not(&mut self, n: &mut MediaNot)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_or(&mut self, n: &mut MediaOr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_queries(&mut self, n: &mut Vec<MediaQuery>)

fn visit_mut_media_query(&mut self, n: &mut MediaQuery)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_query_list(&mut self, n: &mut MediaQueryList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_media_type(&mut self, n: &mut MediaType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_named_namespace(&mut self, n: &mut NamedNamespace)

This method can be overridden to customize the visitor behavior.

fn visit_mut_namespace(&mut self, n: &mut Namespace)

This method can be overridden to customize the visitor behavior.

fn visit_mut_namespace_prefix(&mut self, n: &mut NamespacePrefix)

This method can be overridden to customize the visitor behavior.

fn visit_mut_namespace_prelude(&mut self, n: &mut NamespacePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_namespace_prelude_uri(&mut self, n: &mut NamespacePreludeUri)

This method can be overridden to customize the visitor behavior.

fn visit_mut_nesting_selector(&mut self, n: &mut NestingSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_number(&mut self, n: &mut Number)

This method can be overridden to customize the visitor behavior.

fn visit_mut_opt_at_rule_prelude(&mut self, n: &mut Option<Box<AtRulePrelude>>)

fn visit_mut_opt_atom(&mut self, n: &mut Option<Atom>)

fn visit_mut_opt_attribute_selector_matcher( &mut self, n: &mut Option<AttributeSelectorMatcher> )

fn visit_mut_opt_attribute_selector_modifier( &mut self, n: &mut Option<AttributeSelectorModifier> )

fn visit_mut_opt_attribute_selector_value( &mut self, n: &mut Option<AttributeSelectorValue> )

fn visit_mut_opt_combinator(&mut self, n: &mut Option<Combinator>)

fn visit_mut_opt_container_name(&mut self, n: &mut Option<ContainerName>)

fn visit_mut_opt_forgiving_selector_list( &mut self, n: &mut Option<ForgivingSelectorList> )

fn visit_mut_opt_function(&mut self, n: &mut Option<Box<Function>>)

fn visit_mut_opt_i_32(&mut self, n: &mut Option<i32>)

fn visit_mut_opt_ident(&mut self, n: &mut Option<Ident>)

fn visit_mut_opt_import_conditions( &mut self, n: &mut Option<Box<ImportConditions>> )

fn visit_mut_opt_import_layer_name( &mut self, n: &mut Option<Box<ImportLayerName>> )

fn visit_mut_opt_important_flag(&mut self, n: &mut Option<ImportantFlag>)

fn visit_mut_opt_media_condition_type( &mut self, n: &mut Option<Box<MediaConditionType>> )

fn visit_mut_opt_media_query_list( &mut self, n: &mut Option<Box<MediaQueryList>> )

fn visit_mut_opt_media_type(&mut self, n: &mut Option<MediaType>)

fn visit_mut_opt_namespace(&mut self, n: &mut Option<Namespace>)

fn visit_mut_opt_namespace_prefix(&mut self, n: &mut Option<NamespacePrefix>)

fn visit_mut_opt_nesting_selector(&mut self, n: &mut Option<NestingSelector>)

fn visit_mut_opt_number(&mut self, n: &mut Option<Number>)

fn visit_mut_opt_page_selector_pseudos( &mut self, n: &mut Option<Vec<PageSelectorPseudo>> )

fn visit_mut_opt_page_selector_type(&mut self, n: &mut Option<PageSelectorType>)

fn visit_mut_opt_pseudo_class_selector_children_vec( &mut self, n: &mut Option<Vec<PseudoClassSelectorChildren>> )

fn visit_mut_opt_pseudo_element_selector_children_vec( &mut self, n: &mut Option<Vec<PseudoElementSelectorChildren>> )

fn visit_mut_opt_simple_block(&mut self, n: &mut Option<SimpleBlock>)

fn visit_mut_opt_type_selector(&mut self, n: &mut Option<Box<TypeSelector>>)

fn visit_mut_opt_url_modifiers(&mut self, n: &mut Option<Vec<UrlModifier>>)

fn visit_mut_opt_url_value(&mut self, n: &mut Option<Box<UrlValue>>)

fn visit_mut_page_selector(&mut self, n: &mut PageSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_page_selector_list(&mut self, n: &mut PageSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_page_selector_pseudo(&mut self, n: &mut PageSelectorPseudo)

This method can be overridden to customize the visitor behavior.

fn visit_mut_page_selector_pseudos(&mut self, n: &mut Vec<PageSelectorPseudo>)

fn visit_mut_page_selector_type(&mut self, n: &mut PageSelectorType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_page_selectors(&mut self, n: &mut Vec<PageSelector>)

fn visit_mut_percentage(&mut self, n: &mut Percentage)

This method can be overridden to customize the visitor behavior.

fn visit_mut_pseudo_class_selector(&mut self, n: &mut PseudoClassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_pseudo_class_selector_children( &mut self, n: &mut PseudoClassSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_mut_pseudo_class_selector_children_vec( &mut self, n: &mut Vec<PseudoClassSelectorChildren> )

fn visit_mut_pseudo_element_selector(&mut self, n: &mut PseudoElementSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_pseudo_element_selector_children( &mut self, n: &mut PseudoElementSelectorChildren )

This method can be overridden to customize the visitor behavior.

fn visit_mut_pseudo_element_selector_children_vec( &mut self, n: &mut Vec<PseudoElementSelectorChildren> )

fn visit_mut_qualified_rule(&mut self, n: &mut QualifiedRule)

This method can be overridden to customize the visitor behavior.

fn visit_mut_qualified_rule_prelude(&mut self, n: &mut QualifiedRulePrelude)

This method can be overridden to customize the visitor behavior.

fn visit_mut_query_in_parens(&mut self, n: &mut QueryInParens)

This method can be overridden to customize the visitor behavior.

fn visit_mut_ratio(&mut self, n: &mut Ratio)

This method can be overridden to customize the visitor behavior.

fn visit_mut_relative_selector(&mut self, n: &mut RelativeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_relative_selector_list(&mut self, n: &mut RelativeSelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_relative_selectors(&mut self, n: &mut Vec<RelativeSelector>)

fn visit_mut_resolution(&mut self, n: &mut Resolution)

This method can be overridden to customize the visitor behavior.

fn visit_mut_rule(&mut self, n: &mut Rule)

This method can be overridden to customize the visitor behavior.

fn visit_mut_rules(&mut self, n: &mut Vec<Rule>)

fn visit_mut_scope_range(&mut self, n: &mut ScopeRange)

This method can be overridden to customize the visitor behavior.

fn visit_mut_selector_list(&mut self, n: &mut SelectorList)

This method can be overridden to customize the visitor behavior.

fn visit_mut_sequence_of_custom_idents( &mut self, n: &mut SequenceOfCustomIdents )

This method can be overridden to customize the visitor behavior.

fn visit_mut_simple_block(&mut self, n: &mut SimpleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature(&mut self, n: &mut SizeFeature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_boolean(&mut self, n: &mut SizeFeatureBoolean)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_name(&mut self, n: &mut SizeFeatureName)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_plain(&mut self, n: &mut SizeFeaturePlain)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_range(&mut self, n: &mut SizeFeatureRange)

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_range_comparison( &mut self, n: &mut SizeFeatureRangeComparison )

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_range_interval( &mut self, n: &mut SizeFeatureRangeInterval )

This method can be overridden to customize the visitor behavior.

fn visit_mut_size_feature_value(&mut self, n: &mut SizeFeatureValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_span(&mut self, n: &mut Span)

fn visit_mut_str(&mut self, n: &mut Str)

This method can be overridden to customize the visitor behavior.

fn visit_mut_style_block(&mut self, n: &mut StyleBlock)

This method can be overridden to customize the visitor behavior.

fn visit_mut_stylesheet(&mut self, n: &mut Stylesheet)

This method can be overridden to customize the visitor behavior.

fn visit_mut_subclass_selector(&mut self, n: &mut SubclassSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_subclass_selectors(&mut self, n: &mut Vec<SubclassSelector>)

fn visit_mut_supports_and(&mut self, n: &mut SupportsAnd)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_condition(&mut self, n: &mut SupportsCondition)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_condition_type(&mut self, n: &mut SupportsConditionType)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_condition_types( &mut self, n: &mut Vec<SupportsConditionType> )

fn visit_mut_supports_feature(&mut self, n: &mut SupportsFeature)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_in_parens(&mut self, n: &mut SupportsInParens)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_not(&mut self, n: &mut SupportsNot)

This method can be overridden to customize the visitor behavior.

fn visit_mut_supports_or(&mut self, n: &mut SupportsOr)

This method can be overridden to customize the visitor behavior.

fn visit_mut_tag_name_selector(&mut self, n: &mut TagNameSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_time(&mut self, n: &mut Time)

This method can be overridden to customize the visitor behavior.

fn visit_mut_time_percentage(&mut self, n: &mut TimePercentage)

This method can be overridden to customize the visitor behavior.

fn visit_mut_token(&mut self, n: &mut Token)

fn visit_mut_token_and_span(&mut self, n: &mut TokenAndSpan)

This method can be overridden to customize the visitor behavior.

fn visit_mut_type_selector(&mut self, n: &mut TypeSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_unicode_range(&mut self, n: &mut UnicodeRange)

This method can be overridden to customize the visitor behavior.

fn visit_mut_universal_selector(&mut self, n: &mut UniversalSelector)

This method can be overridden to customize the visitor behavior.

fn visit_mut_unknown_dimension(&mut self, n: &mut UnknownDimension)

This method can be overridden to customize the visitor behavior.

fn visit_mut_url(&mut self, n: &mut Url)

This method can be overridden to customize the visitor behavior.

fn visit_mut_url_modifier(&mut self, n: &mut UrlModifier)

This method can be overridden to customize the visitor behavior.

fn visit_mut_url_modifiers(&mut self, n: &mut Vec<UrlModifier>)

fn visit_mut_url_value(&mut self, n: &mut UrlValue)

This method can be overridden to customize the visitor behavior.

fn visit_mut_url_value_raw(&mut self, n: &mut UrlValueRaw)

This method can be overridden to customize the visitor behavior.

fn visit_mut_wq_name(&mut self, n: &mut WqName)

This method can be overridden to customize the visitor behavior.

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"

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

Write a buffer into this writer, returning how many bytes were written.

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

Attempts to write an entire buffer into this writer.

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

Writes a formatted string into this writer, returning any error encountered.

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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

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

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

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

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

Attempts to write multiple buffers into this writer.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

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

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> StructuralPartialEq for Either<L, R>