pub enum Either<L, R> {
Left(L),
Right(R),
}
__common
only.Expand description
The enum Either
with variants Left
and Right
is a general purpose
sum type with two cases.
The Either
type is symmetric and treats its variants the same way, without
preference.
(For representing success or error, use the regular Result
enum instead.)
Variants§
Implementations§
source§impl<L, R> Either<L, R>
impl<L, R> Either<L, R>
sourcepub fn is_left(&self) -> bool
Available on crate features __ecma
and __utils
only.
pub fn is_left(&self) -> bool
__ecma
and __utils
only.Return true if the value is the Left
variant.
use either::*;
let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_left(), true);
assert_eq!(values[1].is_left(), false);
sourcepub fn is_right(&self) -> bool
Available on crate features __ecma
and __utils
only.
pub fn is_right(&self) -> bool
__ecma
and __utils
only.Return true if the value is the Right
variant.
use either::*;
let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_right(), false);
assert_eq!(values[1].is_right(), true);
sourcepub fn left(self) -> Option<L>
Available on crate features __ecma
and __utils
only.
pub fn left(self) -> Option<L>
__ecma
and __utils
only.Convert the left side of Either<L, R>
to an Option<L>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.left(), Some("some value"));
let right: Either<(), _> = Right(321);
assert_eq!(right.left(), None);
sourcepub fn right(self) -> Option<R>
Available on crate features __ecma
and __utils
only.
pub fn right(self) -> Option<R>
__ecma
and __utils
only.Convert the right side of Either<L, R>
to an Option<R>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.right(), None);
let right: Either<(), _> = Right(321);
assert_eq!(right.right(), Some(321));
sourcepub fn as_ref(&self) -> Either<&L, &R> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn as_ref(&self) -> Either<&L, &R> ⓘ
__ecma
and __utils
only.Convert &Either<L, R>
to Either<&L, &R>
.
use either::*;
let left: Either<_, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));
let right: Either<(), _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));
sourcepub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ
__ecma
and __utils
only.Convert &mut Either<L, R>
to Either<&mut L, &mut R>
.
use either::*;
fn mutate_left(value: &mut Either<u32, u32>) {
if let Some(l) = value.as_mut().left() {
*l = 999;
}
}
let mut left = Left(123);
let mut right = Right(123);
mutate_left(&mut left);
mutate_left(&mut right);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));
sourcepub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ
__ecma
and __utils
only.Convert Pin<&Either<L, R>>
to Either<Pin<&L>, Pin<&R>>
,
pinned projections of the inner variants.
sourcepub fn as_pin_mut(
self: Pin<&mut Either<L, R>>
) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn as_pin_mut( self: Pin<&mut Either<L, R>> ) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ
__ecma
and __utils
only.Convert Pin<&mut Either<L, R>>
to Either<Pin<&mut L>, Pin<&mut R>>
,
pinned projections of the inner variants.
sourcepub fn flip(self) -> Either<R, L> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn flip(self) -> Either<R, L> ⓘ
__ecma
and __utils
only.Convert Either<L, R>
to Either<R, L>
.
use either::*;
let left: Either<_, ()> = Left(123);
assert_eq!(left.flip(), Right(123));
let right: Either<(), _> = Right("some value");
assert_eq!(right.flip(), Left("some value"));
sourcepub fn map_left<F, M>(self, f: F) -> Either<M, R> ⓘwhere
F: FnOnce(L) -> M,
Available on crate features __ecma
and __utils
only.
pub fn map_left<F, M>(self, f: F) -> Either<M, R> ⓘwhere
F: FnOnce(L) -> M,
__ecma
and __utils
only.Apply the function f
on the value in the Left
variant if it is present rewrapping the
result in Left
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_left(|x| x * 2), Left(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_left(|x| x * 2), Right(123));
sourcepub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> S,
Available on crate features __ecma
and __utils
only.
pub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> S,
__ecma
and __utils
only.Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_right(|x| x * 2), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_right(|x| x * 2), Right(246));
sourcepub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
__ecma
and __utils
only.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()));
sourcepub fn map_either_with<Ctx, F, G, M, S>(
self,
ctx: Ctx,
f: F,
g: G
) -> Either<M, S> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn map_either_with<Ctx, F, G, M, S>( self, ctx: Ctx, f: F, g: G ) -> Either<M, S> ⓘ
__ecma
and __utils
only.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);
sourcepub fn either<F, G, T>(self, f: F, g: G) -> T
Available on crate features __ecma
and __utils
only.
pub fn either<F, G, T>(self, f: F, g: G) -> T
__ecma
and __utils
only.Apply one of two functions depending on contents, unifying their result. If the value is
Left(L)
then the first function f
is applied; if it is Right(R)
then the second
function g
is applied.
use either::*;
fn square(n: u32) -> i32 { (n * n) as i32 }
fn negate(n: i32) -> i32 { -n }
let left: Either<u32, i32> = Left(4);
assert_eq!(left.either(square, negate), 16);
let right: Either<u32, i32> = Right(-4);
assert_eq!(right.either(square, negate), 4);
sourcepub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
Available on crate features __ecma
and __utils
only.
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
__ecma
and __utils
only.Like either
, but provide some context to whichever of the
functions ends up being called.
// In this example, the context is a mutable reference
use either::*;
let mut result = Vec::new();
let values = vec![Left(2), Right(2.7)];
for value in values {
value.either_with(&mut result,
|ctx, integer| ctx.push(integer),
|ctx, real| ctx.push(f64::round(real) as i32));
}
assert_eq!(result, vec![2, 3]);
sourcepub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
__ecma
and __utils
only.Apply the function f
on the value in the Left
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
sourcepub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
__ecma
and __utils
only.Apply the function f
on the value in the Right
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
sourcepub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
Available on crate features __ecma
and __utils
only.
pub fn into_iter( self ) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
__ecma
and __utils
only.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]));
sourcepub 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>,
Available on crate features __ecma
and __utils
only.
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>,
__ecma
and __utils
only.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]);
sourcepub 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>,
Available on crate features __ecma
and __utils
only.
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>,
__ecma
and __utils
only.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]);
sourcepub fn factor_into_iter(
self
) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>where
L: IntoIterator,
R: IntoIterator,
Available on crate features __ecma
and __utils
only.
pub fn factor_into_iter(
self
) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>where
L: IntoIterator,
R: IntoIterator,
__ecma
and __utils
only.Converts an Either
of Iterator
s to be an Iterator
of Either
s
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)]);
sourcepub fn factor_iter(
&self
) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
Available on crate features __ecma
and __utils
only.
pub fn factor_iter( &self ) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
__ecma
and __utils
only.Borrows an Either
of Iterator
s to be an Iterator
of Either
s
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)]);
sourcepub fn factor_iter_mut(
&mut self
) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
Available on crate features __ecma
and __utils
only.
pub fn factor_iter_mut( &mut self ) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
__ecma
and __utils
only.Mutably borrows an Either
of Iterator
s to be an Iterator
of Either
s
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]));
sourcepub fn left_or(self, other: L) -> L
Available on crate features __ecma
and __utils
only.
pub fn left_or(self, other: L) -> L
__ecma
and __utils
only.Return left value or given value
Arguments passed to left_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use
left_or_else
, which is lazily evaluated.
§Examples
let left: Either<&str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");
let right: Either<&str, &str> = Right("right");
assert_eq!(right.left_or("left"), "left");
sourcepub fn left_or_default(self) -> Lwhere
L: Default,
Available on crate features __ecma
and __utils
only.
pub fn left_or_default(self) -> Lwhere
L: Default,
__ecma
and __utils
only.Return left or a default
§Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.left_or_default(), "left");
let right: Either<String, u32> = Right(42);
assert_eq!(right.left_or_default(), String::default());
sourcepub fn left_or_else<F>(self, f: F) -> Lwhere
F: FnOnce(R) -> L,
Available on crate features __ecma
and __utils
only.
pub fn left_or_else<F>(self, f: F) -> Lwhere
F: FnOnce(R) -> L,
__ecma
and __utils
only.Returns left value or computes it from a closure
§Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.left_or_else(|_| unreachable!()), "3");
let right: Either<String, u32> = Right(3);
assert_eq!(right.left_or_else(|x| x.to_string()), "3");
sourcepub fn right_or(self, other: R) -> R
Available on crate features __ecma
and __utils
only.
pub fn right_or(self, other: R) -> R
__ecma
and __utils
only.Return right value or given value
Arguments passed to right_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use
right_or_else
, which is lazily evaluated.
§Examples
let right: Either<&str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");
let left: Either<&str, &str> = Left("left");
assert_eq!(left.right_or("right"), "right");
sourcepub fn right_or_default(self) -> Rwhere
R: Default,
Available on crate features __ecma
and __utils
only.
pub fn right_or_default(self) -> Rwhere
R: Default,
__ecma
and __utils
only.Return right or a default
§Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.right_or_default(), u32::default());
let right: Either<String, u32> = Right(42);
assert_eq!(right.right_or_default(), 42);
sourcepub fn right_or_else<F>(self, f: F) -> Rwhere
F: FnOnce(L) -> R,
Available on crate features __ecma
and __utils
only.
pub fn right_or_else<F>(self, f: F) -> Rwhere
F: FnOnce(L) -> R,
__ecma
and __utils
only.Returns right value or computes it from a closure
§Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);
let right: Either<String, u32> = Right(3);
assert_eq!(right.right_or_else(|_| unreachable!()), 3);
sourcepub fn unwrap_left(self) -> Lwhere
R: Debug,
Available on crate features __ecma
and __utils
only.
pub fn unwrap_left(self) -> Lwhere
R: Debug,
__ecma
and __utils
only.sourcepub fn unwrap_right(self) -> Rwhere
L: Debug,
Available on crate features __ecma
and __utils
only.
pub fn unwrap_right(self) -> Rwhere
L: Debug,
__ecma
and __utils
only.sourcepub fn expect_left(self, msg: &str) -> Lwhere
R: Debug,
Available on crate features __ecma
and __utils
only.
pub fn expect_left(self, msg: &str) -> Lwhere
R: Debug,
__ecma
and __utils
only.sourcepub fn expect_right(self, msg: &str) -> Rwhere
L: Debug,
Available on crate features __ecma
and __utils
only.
pub fn expect_right(self, msg: &str) -> Rwhere
L: Debug,
__ecma
and __utils
only.sourcepub fn either_into<T>(self) -> T
Available on crate features __ecma
and __utils
only.
pub fn either_into<T>(self) -> T
__ecma
and __utils
only.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);
source§impl<L, R> Either<Option<L>, Option<R>>
impl<L, R> Either<Option<L>, Option<R>>
sourcepub fn factor_none(self) -> Option<Either<L, R>>
Available on crate features __ecma
and __utils
only.
pub fn factor_none(self) -> Option<Either<L, R>>
__ecma
and __utils
only.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())));
source§impl<L, R, E> Either<Result<L, E>, Result<R, E>>
impl<L, R, E> Either<Result<L, E>, Result<R, E>>
sourcepub fn factor_err(self) -> Result<Either<L, R>, E>
Available on crate features __ecma
and __utils
only.
pub fn factor_err(self) -> Result<Either<L, R>, E>
__ecma
and __utils
only.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())));
source§impl<T, L, R> Either<Result<T, L>, Result<T, R>>
impl<T, L, R> Either<Result<T, L>, Result<T, R>>
sourcepub fn factor_ok(self) -> Result<T, Either<L, R>>
Available on crate features __ecma
and __utils
only.
pub fn factor_ok(self) -> Result<T, Either<L, R>>
__ecma
and __utils
only.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())));
source§impl<T, L, R> Either<(T, L), (T, R)>
impl<T, L, R> Either<(T, L), (T, R)>
sourcepub fn factor_first(self) -> (T, Either<L, R>)
Available on crate features __ecma
and __utils
only.
pub fn factor_first(self) -> (T, Either<L, R>)
__ecma
and __utils
only.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);
source§impl<T, L, R> Either<(L, T), (R, T)>
impl<T, L, R> Either<(L, T), (R, T)>
sourcepub fn factor_second(self) -> (Either<L, R>, T)
Available on crate features __ecma
and __utils
only.
pub fn factor_second(self) -> (Either<L, R>, T)
__ecma
and __utils
only.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);
source§impl<T> Either<T, T>
impl<T> Either<T, T>
sourcepub fn into_inner(self) -> T
Available on crate features __ecma
and __utils
only.
pub fn into_inner(self) -> T
__ecma
and __utils
only.Extract the value of an either over two equivalent types.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.into_inner(), 123);
let right: Either<u32, _> = Right(123);
assert_eq!(right.into_inner(), 123);
sourcepub fn map<F, M>(self, f: F) -> Either<M, M> ⓘwhere
F: FnOnce(T) -> M,
Available on crate features __ecma
and __utils
only.
pub fn map<F, M>(self, f: F) -> Either<M, M> ⓘwhere
F: FnOnce(T) -> M,
__ecma
and __utils
only.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§
source§impl<L, R, Target> AsMut<Target> for Either<L, R>
impl<L, R, Target> AsMut<Target> for Either<L, R>
source§fn as_mut(&mut self) -> &mut Target
fn as_mut(&mut self) -> &mut Target
source§impl<L, R> BufRead for Either<L, R>
impl<L, R> BufRead for Either<L, R>
Requires crate feature "use_std"
source§fn fill_buf(&mut self) -> Result<&[u8], Error>
fn fill_buf(&mut self) -> Result<&[u8], Error>
source§fn consume(&mut self, amt: usize)
fn consume(&mut self, amt: usize)
amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read moresource§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
0xA
byte) is reached, and append
them to the provided String
buffer. Read moresource§fn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Read
has any data left to be read. Read moresource§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
bufread_skip_until
)byte
or EOF is reached. Read moresource§impl<L, R> DoubleEndedIterator for Either<L, R>
impl<L, R> DoubleEndedIterator for Either<L, R>
source§fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
source§fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
source§fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
source§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read moresource§impl<L, R> Error for Either<L, R>
impl<L, R> Error for Either<L, R>
Either
implements Error
if both L
and R
implement it.
Requires crate feature "use_std"
source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
source§fn description(&self) -> &str
fn description(&self) -> &str
source§impl<L, R> ExactSizeIterator for Either<L, R>
impl<L, R> ExactSizeIterator for Either<L, R>
source§impl<L, R, A> Extend<A> for Either<L, R>
impl<L, R, A> Extend<A> for Either<L, R>
source§fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = A>,
fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = A>,
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)§impl<A, B> Fold for Either<A, B>
impl<A, B> Fold for Either<A, B>
§fn fold_accessibility(&mut self, n: Accessibility) -> Accessibility
fn fold_accessibility(&mut self, n: Accessibility) -> Accessibility
§fn fold_array_lit(&mut self, n: ArrayLit) -> ArrayLit
fn fold_array_lit(&mut self, n: ArrayLit) -> ArrayLit
§fn fold_array_pat(&mut self, n: ArrayPat) -> ArrayPat
fn fold_array_pat(&mut self, n: ArrayPat) -> ArrayPat
§fn fold_arrow_expr(&mut self, n: ArrowExpr) -> ArrowExpr
fn fold_arrow_expr(&mut self, n: ArrowExpr) -> ArrowExpr
§fn fold_assign_expr(&mut self, n: AssignExpr) -> AssignExpr
fn fold_assign_expr(&mut self, n: AssignExpr) -> AssignExpr
§fn fold_assign_op(&mut self, n: AssignOp) -> AssignOp
fn fold_assign_op(&mut self, n: AssignOp) -> AssignOp
§fn fold_assign_pat(&mut self, n: AssignPat) -> AssignPat
fn fold_assign_pat(&mut self, n: AssignPat) -> AssignPat
§fn fold_assign_pat_prop(&mut self, n: AssignPatProp) -> AssignPatProp
fn fold_assign_pat_prop(&mut self, n: AssignPatProp) -> AssignPatProp
§fn fold_assign_prop(&mut self, n: AssignProp) -> AssignProp
fn fold_assign_prop(&mut self, n: AssignProp) -> AssignProp
§fn fold_assign_target(&mut self, n: AssignTarget) -> AssignTarget
fn fold_assign_target(&mut self, n: AssignTarget) -> AssignTarget
§fn fold_assign_target_pat(&mut self, n: AssignTargetPat) -> AssignTargetPat
fn fold_assign_target_pat(&mut self, n: AssignTargetPat) -> AssignTargetPat
fn fold_atom(&mut self, n: Atom) -> Atom
§fn fold_auto_accessor(&mut self, n: AutoAccessor) -> AutoAccessor
fn fold_auto_accessor(&mut self, n: AutoAccessor) -> AutoAccessor
§fn fold_await_expr(&mut self, n: AwaitExpr) -> AwaitExpr
fn fold_await_expr(&mut self, n: AwaitExpr) -> AwaitExpr
§fn fold_big_int(&mut self, n: BigInt) -> BigInt
fn fold_big_int(&mut self, n: BigInt) -> BigInt
fn fold_big_int_value(&mut self, n: BigInt) -> BigInt
§fn fold_bin_expr(&mut self, n: BinExpr) -> BinExpr
fn fold_bin_expr(&mut self, n: BinExpr) -> BinExpr
§fn fold_binary_op(&mut self, n: BinaryOp) -> BinaryOp
fn fold_binary_op(&mut self, n: BinaryOp) -> BinaryOp
§fn fold_binding_ident(&mut self, n: BindingIdent) -> BindingIdent
fn fold_binding_ident(&mut self, n: BindingIdent) -> BindingIdent
§fn fold_block_stmt(&mut self, n: BlockStmt) -> BlockStmt
fn fold_block_stmt(&mut self, n: BlockStmt) -> BlockStmt
§fn fold_block_stmt_or_expr(&mut self, n: BlockStmtOrExpr) -> BlockStmtOrExpr
fn fold_block_stmt_or_expr(&mut self, n: BlockStmtOrExpr) -> BlockStmtOrExpr
§fn fold_bool(&mut self, n: Bool) -> Bool
fn fold_bool(&mut self, n: Bool) -> Bool
§fn fold_break_stmt(&mut self, n: BreakStmt) -> BreakStmt
fn fold_break_stmt(&mut self, n: BreakStmt) -> BreakStmt
§fn fold_call_expr(&mut self, n: CallExpr) -> CallExpr
fn fold_call_expr(&mut self, n: CallExpr) -> CallExpr
§fn fold_callee(&mut self, n: Callee) -> Callee
fn fold_callee(&mut self, n: Callee) -> Callee
§fn fold_catch_clause(&mut self, n: CatchClause) -> CatchClause
fn fold_catch_clause(&mut self, n: CatchClause) -> CatchClause
§fn fold_class(&mut self, n: Class) -> Class
fn fold_class(&mut self, n: Class) -> Class
§fn fold_class_decl(&mut self, n: ClassDecl) -> ClassDecl
fn fold_class_decl(&mut self, n: ClassDecl) -> ClassDecl
§fn fold_class_expr(&mut self, n: ClassExpr) -> ClassExpr
fn fold_class_expr(&mut self, n: ClassExpr) -> ClassExpr
§fn fold_class_member(&mut self, n: ClassMember) -> ClassMember
fn fold_class_member(&mut self, n: ClassMember) -> ClassMember
fn fold_class_members(&mut self, n: Vec<ClassMember>) -> Vec<ClassMember>
§fn fold_class_method(&mut self, n: ClassMethod) -> ClassMethod
fn fold_class_method(&mut self, n: ClassMethod) -> ClassMethod
§fn fold_class_prop(&mut self, n: ClassProp) -> ClassProp
fn fold_class_prop(&mut self, n: ClassProp) -> ClassProp
§fn fold_computed_prop_name(&mut self, n: ComputedPropName) -> ComputedPropName
fn fold_computed_prop_name(&mut self, n: ComputedPropName) -> ComputedPropName
§fn fold_cond_expr(&mut self, n: CondExpr) -> CondExpr
fn fold_cond_expr(&mut self, n: CondExpr) -> CondExpr
§fn fold_constructor(&mut self, n: Constructor) -> Constructor
fn fold_constructor(&mut self, n: Constructor) -> Constructor
§fn fold_continue_stmt(&mut self, n: ContinueStmt) -> ContinueStmt
fn fold_continue_stmt(&mut self, n: ContinueStmt) -> ContinueStmt
§fn fold_debugger_stmt(&mut self, n: DebuggerStmt) -> DebuggerStmt
fn fold_debugger_stmt(&mut self, n: DebuggerStmt) -> DebuggerStmt
§fn fold_decl(&mut self, n: Decl) -> Decl
fn fold_decl(&mut self, n: Decl) -> Decl
§fn fold_decorator(&mut self, n: Decorator) -> Decorator
fn fold_decorator(&mut self, n: Decorator) -> Decorator
fn fold_decorators(&mut self, n: Vec<Decorator>) -> Vec<Decorator>
§fn fold_default_decl(&mut self, n: DefaultDecl) -> DefaultDecl
fn fold_default_decl(&mut self, n: DefaultDecl) -> DefaultDecl
§fn fold_do_while_stmt(&mut self, n: DoWhileStmt) -> DoWhileStmt
fn fold_do_while_stmt(&mut self, n: DoWhileStmt) -> DoWhileStmt
§fn fold_empty_stmt(&mut self, n: EmptyStmt) -> EmptyStmt
fn fold_empty_stmt(&mut self, n: EmptyStmt) -> EmptyStmt
§fn fold_export_all(&mut self, n: ExportAll) -> ExportAll
fn fold_export_all(&mut self, n: ExportAll) -> ExportAll
§fn fold_export_decl(&mut self, n: ExportDecl) -> ExportDecl
fn fold_export_decl(&mut self, n: ExportDecl) -> ExportDecl
§fn fold_export_default_decl(
&mut self,
n: ExportDefaultDecl
) -> ExportDefaultDecl
fn fold_export_default_decl( &mut self, n: ExportDefaultDecl ) -> ExportDefaultDecl
§fn fold_export_default_expr(
&mut self,
n: ExportDefaultExpr
) -> ExportDefaultExpr
fn fold_export_default_expr( &mut self, n: ExportDefaultExpr ) -> ExportDefaultExpr
§fn fold_export_default_specifier(
&mut self,
n: ExportDefaultSpecifier
) -> ExportDefaultSpecifier
fn fold_export_default_specifier( &mut self, n: ExportDefaultSpecifier ) -> ExportDefaultSpecifier
§fn fold_export_named_specifier(
&mut self,
n: ExportNamedSpecifier
) -> ExportNamedSpecifier
fn fold_export_named_specifier( &mut self, n: ExportNamedSpecifier ) -> ExportNamedSpecifier
§fn fold_export_namespace_specifier(
&mut self,
n: ExportNamespaceSpecifier
) -> ExportNamespaceSpecifier
fn fold_export_namespace_specifier( &mut self, n: ExportNamespaceSpecifier ) -> ExportNamespaceSpecifier
§fn fold_export_specifier(&mut self, n: ExportSpecifier) -> ExportSpecifier
fn fold_export_specifier(&mut self, n: ExportSpecifier) -> ExportSpecifier
fn fold_export_specifiers( &mut self, n: Vec<ExportSpecifier> ) -> Vec<ExportSpecifier>
§fn fold_expr(&mut self, n: Expr) -> Expr
fn fold_expr(&mut self, n: Expr) -> Expr
§fn fold_expr_or_spread(&mut self, n: ExprOrSpread) -> ExprOrSpread
fn fold_expr_or_spread(&mut self, n: ExprOrSpread) -> ExprOrSpread
fn fold_expr_or_spreads(&mut self, n: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>
§fn fold_expr_stmt(&mut self, n: ExprStmt) -> ExprStmt
fn fold_expr_stmt(&mut self, n: ExprStmt) -> ExprStmt
fn fold_exprs(&mut self, n: Vec<Box<Expr>>) -> Vec<Box<Expr>>
§fn fold_fn_decl(&mut self, n: FnDecl) -> FnDecl
fn fold_fn_decl(&mut self, n: FnDecl) -> FnDecl
§fn fold_fn_expr(&mut self, n: FnExpr) -> FnExpr
fn fold_fn_expr(&mut self, n: FnExpr) -> FnExpr
§fn fold_for_head(&mut self, n: ForHead) -> ForHead
fn fold_for_head(&mut self, n: ForHead) -> ForHead
§fn fold_for_in_stmt(&mut self, n: ForInStmt) -> ForInStmt
fn fold_for_in_stmt(&mut self, n: ForInStmt) -> ForInStmt
§fn fold_for_of_stmt(&mut self, n: ForOfStmt) -> ForOfStmt
fn fold_for_of_stmt(&mut self, n: ForOfStmt) -> ForOfStmt
§fn fold_for_stmt(&mut self, n: ForStmt) -> ForStmt
fn fold_for_stmt(&mut self, n: ForStmt) -> ForStmt
§fn fold_function(&mut self, n: Function) -> Function
fn fold_function(&mut self, n: Function) -> Function
§fn fold_getter_prop(&mut self, n: GetterProp) -> GetterProp
fn fold_getter_prop(&mut self, n: GetterProp) -> GetterProp
§fn fold_ident(&mut self, n: Ident) -> Ident
fn fold_ident(&mut self, n: Ident) -> Ident
§fn fold_if_stmt(&mut self, n: IfStmt) -> IfStmt
fn fold_if_stmt(&mut self, n: IfStmt) -> IfStmt
§fn fold_import(&mut self, n: Import) -> Import
fn fold_import(&mut self, n: Import) -> Import
§fn fold_import_decl(&mut self, n: ImportDecl) -> ImportDecl
fn fold_import_decl(&mut self, n: ImportDecl) -> ImportDecl
§fn fold_import_default_specifier(
&mut self,
n: ImportDefaultSpecifier
) -> ImportDefaultSpecifier
fn fold_import_default_specifier( &mut self, n: ImportDefaultSpecifier ) -> ImportDefaultSpecifier
§fn fold_import_named_specifier(
&mut self,
n: ImportNamedSpecifier
) -> ImportNamedSpecifier
fn fold_import_named_specifier( &mut self, n: ImportNamedSpecifier ) -> ImportNamedSpecifier
fn fold_import_phase(&mut self, n: ImportPhase) -> ImportPhase
§fn fold_import_specifier(&mut self, n: ImportSpecifier) -> ImportSpecifier
fn fold_import_specifier(&mut self, n: ImportSpecifier) -> ImportSpecifier
fn fold_import_specifiers( &mut self, n: Vec<ImportSpecifier> ) -> Vec<ImportSpecifier>
§fn fold_import_star_as_specifier(
&mut self,
n: ImportStarAsSpecifier
) -> ImportStarAsSpecifier
fn fold_import_star_as_specifier( &mut self, n: ImportStarAsSpecifier ) -> ImportStarAsSpecifier
§fn fold_invalid(&mut self, n: Invalid) -> Invalid
fn fold_invalid(&mut self, n: Invalid) -> Invalid
§fn fold_jsx_attr(&mut self, n: JSXAttr) -> JSXAttr
fn fold_jsx_attr(&mut self, n: JSXAttr) -> JSXAttr
§fn fold_jsx_attr_name(&mut self, n: JSXAttrName) -> JSXAttrName
fn fold_jsx_attr_name(&mut self, n: JSXAttrName) -> JSXAttrName
§fn fold_jsx_attr_or_spread(&mut self, n: JSXAttrOrSpread) -> JSXAttrOrSpread
fn fold_jsx_attr_or_spread(&mut self, n: JSXAttrOrSpread) -> JSXAttrOrSpread
fn fold_jsx_attr_or_spreads( &mut self, n: Vec<JSXAttrOrSpread> ) -> Vec<JSXAttrOrSpread>
§fn fold_jsx_attr_value(&mut self, n: JSXAttrValue) -> JSXAttrValue
fn fold_jsx_attr_value(&mut self, n: JSXAttrValue) -> JSXAttrValue
§fn fold_jsx_closing_element(
&mut self,
n: JSXClosingElement
) -> JSXClosingElement
fn fold_jsx_closing_element( &mut self, n: JSXClosingElement ) -> JSXClosingElement
§fn fold_jsx_closing_fragment(
&mut self,
n: JSXClosingFragment
) -> JSXClosingFragment
fn fold_jsx_closing_fragment( &mut self, n: JSXClosingFragment ) -> JSXClosingFragment
§fn fold_jsx_element(&mut self, n: JSXElement) -> JSXElement
fn fold_jsx_element(&mut self, n: JSXElement) -> JSXElement
§fn fold_jsx_element_child(&mut self, n: JSXElementChild) -> JSXElementChild
fn fold_jsx_element_child(&mut self, n: JSXElementChild) -> JSXElementChild
fn fold_jsx_element_children( &mut self, n: Vec<JSXElementChild> ) -> Vec<JSXElementChild>
§fn fold_jsx_element_name(&mut self, n: JSXElementName) -> JSXElementName
fn fold_jsx_element_name(&mut self, n: JSXElementName) -> JSXElementName
§fn fold_jsx_empty_expr(&mut self, n: JSXEmptyExpr) -> JSXEmptyExpr
fn fold_jsx_empty_expr(&mut self, n: JSXEmptyExpr) -> JSXEmptyExpr
§fn fold_jsx_expr(&mut self, n: JSXExpr) -> JSXExpr
fn fold_jsx_expr(&mut self, n: JSXExpr) -> JSXExpr
§fn fold_jsx_expr_container(&mut self, n: JSXExprContainer) -> JSXExprContainer
fn fold_jsx_expr_container(&mut self, n: JSXExprContainer) -> JSXExprContainer
§fn fold_jsx_fragment(&mut self, n: JSXFragment) -> JSXFragment
fn fold_jsx_fragment(&mut self, n: JSXFragment) -> JSXFragment
§fn fold_jsx_member_expr(&mut self, n: JSXMemberExpr) -> JSXMemberExpr
fn fold_jsx_member_expr(&mut self, n: JSXMemberExpr) -> JSXMemberExpr
§fn fold_jsx_namespaced_name(
&mut self,
n: JSXNamespacedName
) -> JSXNamespacedName
fn fold_jsx_namespaced_name( &mut self, n: JSXNamespacedName ) -> JSXNamespacedName
§fn fold_jsx_object(&mut self, n: JSXObject) -> JSXObject
fn fold_jsx_object(&mut self, n: JSXObject) -> JSXObject
§fn fold_jsx_opening_element(
&mut self,
n: JSXOpeningElement
) -> JSXOpeningElement
fn fold_jsx_opening_element( &mut self, n: JSXOpeningElement ) -> JSXOpeningElement
§fn fold_jsx_opening_fragment(
&mut self,
n: JSXOpeningFragment
) -> JSXOpeningFragment
fn fold_jsx_opening_fragment( &mut self, n: JSXOpeningFragment ) -> JSXOpeningFragment
§fn fold_jsx_spread_child(&mut self, n: JSXSpreadChild) -> JSXSpreadChild
fn fold_jsx_spread_child(&mut self, n: JSXSpreadChild) -> JSXSpreadChild
§fn fold_jsx_text(&mut self, n: JSXText) -> JSXText
fn fold_jsx_text(&mut self, n: JSXText) -> JSXText
§fn fold_key(&mut self, n: Key) -> Key
fn fold_key(&mut self, n: Key) -> Key
§fn fold_key_value_pat_prop(&mut self, n: KeyValuePatProp) -> KeyValuePatProp
fn fold_key_value_pat_prop(&mut self, n: KeyValuePatProp) -> KeyValuePatProp
§fn fold_key_value_prop(&mut self, n: KeyValueProp) -> KeyValueProp
fn fold_key_value_prop(&mut self, n: KeyValueProp) -> KeyValueProp
§fn fold_labeled_stmt(&mut self, n: LabeledStmt) -> LabeledStmt
fn fold_labeled_stmt(&mut self, n: LabeledStmt) -> LabeledStmt
§fn fold_lit(&mut self, n: Lit) -> Lit
fn fold_lit(&mut self, n: Lit) -> Lit
§fn fold_member_expr(&mut self, n: MemberExpr) -> MemberExpr
fn fold_member_expr(&mut self, n: MemberExpr) -> MemberExpr
§fn fold_member_prop(&mut self, n: MemberProp) -> MemberProp
fn fold_member_prop(&mut self, n: MemberProp) -> MemberProp
§fn fold_meta_prop_expr(&mut self, n: MetaPropExpr) -> MetaPropExpr
fn fold_meta_prop_expr(&mut self, n: MetaPropExpr) -> MetaPropExpr
§fn fold_meta_prop_kind(&mut self, n: MetaPropKind) -> MetaPropKind
fn fold_meta_prop_kind(&mut self, n: MetaPropKind) -> MetaPropKind
§fn fold_method_kind(&mut self, n: MethodKind) -> MethodKind
fn fold_method_kind(&mut self, n: MethodKind) -> MethodKind
§fn fold_method_prop(&mut self, n: MethodProp) -> MethodProp
fn fold_method_prop(&mut self, n: MethodProp) -> MethodProp
§fn fold_module(&mut self, n: Module) -> Module
fn fold_module(&mut self, n: Module) -> Module
§fn fold_module_decl(&mut self, n: ModuleDecl) -> ModuleDecl
fn fold_module_decl(&mut self, n: ModuleDecl) -> ModuleDecl
§fn fold_module_export_name(&mut self, n: ModuleExportName) -> ModuleExportName
fn fold_module_export_name(&mut self, n: ModuleExportName) -> ModuleExportName
§fn fold_module_item(&mut self, n: ModuleItem) -> ModuleItem
fn fold_module_item(&mut self, n: ModuleItem) -> ModuleItem
fn fold_module_items(&mut self, n: Vec<ModuleItem>) -> Vec<ModuleItem>
§fn fold_named_export(&mut self, n: NamedExport) -> NamedExport
fn fold_named_export(&mut self, n: NamedExport) -> NamedExport
§fn fold_new_expr(&mut self, n: NewExpr) -> NewExpr
fn fold_new_expr(&mut self, n: NewExpr) -> NewExpr
§fn fold_null(&mut self, n: Null) -> Null
fn fold_null(&mut self, n: Null) -> Null
§fn fold_number(&mut self, n: Number) -> Number
fn fold_number(&mut self, n: Number) -> Number
§fn fold_object_lit(&mut self, n: ObjectLit) -> ObjectLit
fn fold_object_lit(&mut self, n: ObjectLit) -> ObjectLit
§fn fold_object_pat(&mut self, n: ObjectPat) -> ObjectPat
fn fold_object_pat(&mut self, n: ObjectPat) -> ObjectPat
§fn fold_object_pat_prop(&mut self, n: ObjectPatProp) -> ObjectPatProp
fn fold_object_pat_prop(&mut self, n: ObjectPatProp) -> ObjectPatProp
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
fn fold_opt_call(&mut self, n: OptCall) -> OptCall
fn fold_opt_catch_clause( &mut self, n: Option<CatchClause> ) -> Option<CatchClause>
§fn fold_opt_chain_base(&mut self, n: OptChainBase) -> OptChainBase
fn fold_opt_chain_base(&mut self, n: OptChainBase) -> OptChainBase
§fn fold_opt_chain_expr(&mut self, n: OptChainExpr) -> OptChainExpr
fn fold_opt_chain_expr(&mut self, n: OptChainExpr) -> OptChainExpr
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
fn fold_param(&mut self, n: Param) -> Param
§fn fold_param_or_ts_param_prop(
&mut self,
n: ParamOrTsParamProp
) -> ParamOrTsParamProp
fn fold_param_or_ts_param_prop( &mut self, n: ParamOrTsParamProp ) -> ParamOrTsParamProp
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
fn fold_paren_expr(&mut self, n: ParenExpr) -> ParenExpr
§fn fold_pat(&mut self, n: Pat) -> Pat
fn fold_pat(&mut self, n: Pat) -> Pat
fn fold_pats(&mut self, n: Vec<Pat>) -> Vec<Pat>
§fn fold_private_method(&mut self, n: PrivateMethod) -> PrivateMethod
fn fold_private_method(&mut self, n: PrivateMethod) -> PrivateMethod
§fn fold_private_name(&mut self, n: PrivateName) -> PrivateName
fn fold_private_name(&mut self, n: PrivateName) -> PrivateName
§fn fold_private_prop(&mut self, n: PrivateProp) -> PrivateProp
fn fold_private_prop(&mut self, n: PrivateProp) -> PrivateProp
§fn fold_program(&mut self, n: Program) -> Program
fn fold_program(&mut self, n: Program) -> Program
§fn fold_prop(&mut self, n: Prop) -> Prop
fn fold_prop(&mut self, n: Prop) -> Prop
§fn fold_prop_name(&mut self, n: PropName) -> PropName
fn fold_prop_name(&mut self, n: PropName) -> PropName
§fn fold_prop_or_spread(&mut self, n: PropOrSpread) -> PropOrSpread
fn fold_prop_or_spread(&mut self, n: PropOrSpread) -> PropOrSpread
fn fold_prop_or_spreads(&mut self, n: Vec<PropOrSpread>) -> Vec<PropOrSpread>
§fn fold_regex(&mut self, n: Regex) -> Regex
fn fold_regex(&mut self, n: Regex) -> Regex
§fn fold_reserved_unused(&mut self, n: ReservedUnused) -> ReservedUnused
fn fold_reserved_unused(&mut self, n: ReservedUnused) -> ReservedUnused
§fn fold_rest_pat(&mut self, n: RestPat) -> RestPat
fn fold_rest_pat(&mut self, n: RestPat) -> RestPat
§fn fold_return_stmt(&mut self, n: ReturnStmt) -> ReturnStmt
fn fold_return_stmt(&mut self, n: ReturnStmt) -> ReturnStmt
§fn fold_script(&mut self, n: Script) -> Script
fn fold_script(&mut self, n: Script) -> Script
§fn fold_seq_expr(&mut self, n: SeqExpr) -> SeqExpr
fn fold_seq_expr(&mut self, n: SeqExpr) -> SeqExpr
§fn fold_setter_prop(&mut self, n: SetterProp) -> SetterProp
fn fold_setter_prop(&mut self, n: SetterProp) -> SetterProp
§fn fold_simple_assign_target(
&mut self,
n: SimpleAssignTarget
) -> SimpleAssignTarget
fn fold_simple_assign_target( &mut self, n: SimpleAssignTarget ) -> SimpleAssignTarget
fn fold_span(&mut self, n: Span) -> Span
§fn fold_spread_element(&mut self, n: SpreadElement) -> SpreadElement
fn fold_spread_element(&mut self, n: SpreadElement) -> SpreadElement
§fn fold_static_block(&mut self, n: StaticBlock) -> StaticBlock
fn fold_static_block(&mut self, n: StaticBlock) -> StaticBlock
§fn fold_stmt(&mut self, n: Stmt) -> Stmt
fn fold_stmt(&mut self, n: Stmt) -> Stmt
fn fold_stmts(&mut self, n: Vec<Stmt>) -> Vec<Stmt>
§fn fold_str(&mut self, n: Str) -> Str
fn fold_str(&mut self, n: Str) -> Str
§fn fold_super(&mut self, n: Super) -> Super
fn fold_super(&mut self, n: Super) -> Super
§fn fold_super_prop(&mut self, n: SuperProp) -> SuperProp
fn fold_super_prop(&mut self, n: SuperProp) -> SuperProp
§fn fold_super_prop_expr(&mut self, n: SuperPropExpr) -> SuperPropExpr
fn fold_super_prop_expr(&mut self, n: SuperPropExpr) -> SuperPropExpr
§fn fold_switch_case(&mut self, n: SwitchCase) -> SwitchCase
fn fold_switch_case(&mut self, n: SwitchCase) -> SwitchCase
fn fold_switch_cases(&mut self, n: Vec<SwitchCase>) -> Vec<SwitchCase>
§fn fold_switch_stmt(&mut self, n: SwitchStmt) -> SwitchStmt
fn fold_switch_stmt(&mut self, n: SwitchStmt) -> SwitchStmt
§fn fold_tagged_tpl(&mut self, n: TaggedTpl) -> TaggedTpl
fn fold_tagged_tpl(&mut self, n: TaggedTpl) -> TaggedTpl
§fn fold_this_expr(&mut self, n: ThisExpr) -> ThisExpr
fn fold_this_expr(&mut self, n: ThisExpr) -> ThisExpr
§fn fold_throw_stmt(&mut self, n: ThrowStmt) -> ThrowStmt
fn fold_throw_stmt(&mut self, n: ThrowStmt) -> ThrowStmt
§fn fold_tpl(&mut self, n: Tpl) -> Tpl
fn fold_tpl(&mut self, n: Tpl) -> Tpl
§fn fold_tpl_element(&mut self, n: TplElement) -> TplElement
fn fold_tpl_element(&mut self, n: TplElement) -> TplElement
fn fold_tpl_elements(&mut self, n: Vec<TplElement>) -> Vec<TplElement>
§fn fold_true_plus_minus(&mut self, n: TruePlusMinus) -> TruePlusMinus
fn fold_true_plus_minus(&mut self, n: TruePlusMinus) -> TruePlusMinus
§fn fold_try_stmt(&mut self, n: TryStmt) -> TryStmt
fn fold_try_stmt(&mut self, n: TryStmt) -> TryStmt
§fn fold_ts_array_type(&mut self, n: TsArrayType) -> TsArrayType
fn fold_ts_array_type(&mut self, n: TsArrayType) -> TsArrayType
§fn fold_ts_as_expr(&mut self, n: TsAsExpr) -> TsAsExpr
fn fold_ts_as_expr(&mut self, n: TsAsExpr) -> TsAsExpr
§fn fold_ts_call_signature_decl(
&mut self,
n: TsCallSignatureDecl
) -> TsCallSignatureDecl
fn fold_ts_call_signature_decl( &mut self, n: TsCallSignatureDecl ) -> TsCallSignatureDecl
§fn fold_ts_conditional_type(
&mut self,
n: TsConditionalType
) -> TsConditionalType
fn fold_ts_conditional_type( &mut self, n: TsConditionalType ) -> TsConditionalType
§fn fold_ts_const_assertion(&mut self, n: TsConstAssertion) -> TsConstAssertion
fn fold_ts_const_assertion(&mut self, n: TsConstAssertion) -> TsConstAssertion
§fn fold_ts_construct_signature_decl(
&mut self,
n: TsConstructSignatureDecl
) -> TsConstructSignatureDecl
fn fold_ts_construct_signature_decl( &mut self, n: TsConstructSignatureDecl ) -> TsConstructSignatureDecl
§fn fold_ts_constructor_type(
&mut self,
n: TsConstructorType
) -> TsConstructorType
fn fold_ts_constructor_type( &mut self, n: TsConstructorType ) -> TsConstructorType
§fn fold_ts_entity_name(&mut self, n: TsEntityName) -> TsEntityName
fn fold_ts_entity_name(&mut self, n: TsEntityName) -> TsEntityName
§fn fold_ts_enum_decl(&mut self, n: TsEnumDecl) -> TsEnumDecl
fn fold_ts_enum_decl(&mut self, n: TsEnumDecl) -> TsEnumDecl
§fn fold_ts_enum_member(&mut self, n: TsEnumMember) -> TsEnumMember
fn fold_ts_enum_member(&mut self, n: TsEnumMember) -> TsEnumMember
§fn fold_ts_enum_member_id(&mut self, n: TsEnumMemberId) -> TsEnumMemberId
fn fold_ts_enum_member_id(&mut self, n: TsEnumMemberId) -> TsEnumMemberId
fn fold_ts_enum_members(&mut self, n: Vec<TsEnumMember>) -> Vec<TsEnumMember>
§fn fold_ts_export_assignment(
&mut self,
n: TsExportAssignment
) -> TsExportAssignment
fn fold_ts_export_assignment( &mut self, n: TsExportAssignment ) -> TsExportAssignment
§fn fold_ts_expr_with_type_args(
&mut self,
n: TsExprWithTypeArgs
) -> TsExprWithTypeArgs
fn fold_ts_expr_with_type_args( &mut self, n: TsExprWithTypeArgs ) -> TsExprWithTypeArgs
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
fn fold_ts_external_module_ref( &mut self, n: TsExternalModuleRef ) -> TsExternalModuleRef
§fn fold_ts_fn_or_constructor_type(
&mut self,
n: TsFnOrConstructorType
) -> TsFnOrConstructorType
fn fold_ts_fn_or_constructor_type( &mut self, n: TsFnOrConstructorType ) -> TsFnOrConstructorType
§fn fold_ts_fn_param(&mut self, n: TsFnParam) -> TsFnParam
fn fold_ts_fn_param(&mut self, n: TsFnParam) -> TsFnParam
fn fold_ts_fn_params(&mut self, n: Vec<TsFnParam>) -> Vec<TsFnParam>
§fn fold_ts_fn_type(&mut self, n: TsFnType) -> TsFnType
fn fold_ts_fn_type(&mut self, n: TsFnType) -> TsFnType
§fn fold_ts_getter_signature(
&mut self,
n: TsGetterSignature
) -> TsGetterSignature
fn fold_ts_getter_signature( &mut self, n: TsGetterSignature ) -> TsGetterSignature
§fn fold_ts_import_equals_decl(
&mut self,
n: TsImportEqualsDecl
) -> TsImportEqualsDecl
fn fold_ts_import_equals_decl( &mut self, n: TsImportEqualsDecl ) -> TsImportEqualsDecl
§fn fold_ts_import_type(&mut self, n: TsImportType) -> TsImportType
fn fold_ts_import_type(&mut self, n: TsImportType) -> TsImportType
§fn fold_ts_index_signature(&mut self, n: TsIndexSignature) -> TsIndexSignature
fn fold_ts_index_signature(&mut self, n: TsIndexSignature) -> TsIndexSignature
§fn fold_ts_indexed_access_type(
&mut self,
n: TsIndexedAccessType
) -> TsIndexedAccessType
fn fold_ts_indexed_access_type( &mut self, n: TsIndexedAccessType ) -> TsIndexedAccessType
§fn fold_ts_infer_type(&mut self, n: TsInferType) -> TsInferType
fn fold_ts_infer_type(&mut self, n: TsInferType) -> TsInferType
§fn fold_ts_instantiation(&mut self, n: TsInstantiation) -> TsInstantiation
fn fold_ts_instantiation(&mut self, n: TsInstantiation) -> TsInstantiation
§fn fold_ts_interface_body(&mut self, n: TsInterfaceBody) -> TsInterfaceBody
fn fold_ts_interface_body(&mut self, n: TsInterfaceBody) -> TsInterfaceBody
§fn fold_ts_interface_decl(&mut self, n: TsInterfaceDecl) -> TsInterfaceDecl
fn fold_ts_interface_decl(&mut self, n: TsInterfaceDecl) -> TsInterfaceDecl
§fn fold_ts_intersection_type(
&mut self,
n: TsIntersectionType
) -> TsIntersectionType
fn fold_ts_intersection_type( &mut self, n: TsIntersectionType ) -> TsIntersectionType
§fn fold_ts_keyword_type(&mut self, n: TsKeywordType) -> TsKeywordType
fn fold_ts_keyword_type(&mut self, n: TsKeywordType) -> TsKeywordType
§fn fold_ts_keyword_type_kind(
&mut self,
n: TsKeywordTypeKind
) -> TsKeywordTypeKind
fn fold_ts_keyword_type_kind( &mut self, n: TsKeywordTypeKind ) -> TsKeywordTypeKind
§fn fold_ts_lit(&mut self, n: TsLit) -> TsLit
fn fold_ts_lit(&mut self, n: TsLit) -> TsLit
§fn fold_ts_lit_type(&mut self, n: TsLitType) -> TsLitType
fn fold_ts_lit_type(&mut self, n: TsLitType) -> TsLitType
§fn fold_ts_mapped_type(&mut self, n: TsMappedType) -> TsMappedType
fn fold_ts_mapped_type(&mut self, n: TsMappedType) -> TsMappedType
§fn fold_ts_method_signature(
&mut self,
n: TsMethodSignature
) -> TsMethodSignature
fn fold_ts_method_signature( &mut self, n: TsMethodSignature ) -> TsMethodSignature
§fn fold_ts_module_block(&mut self, n: TsModuleBlock) -> TsModuleBlock
fn fold_ts_module_block(&mut self, n: TsModuleBlock) -> TsModuleBlock
§fn fold_ts_module_decl(&mut self, n: TsModuleDecl) -> TsModuleDecl
fn fold_ts_module_decl(&mut self, n: TsModuleDecl) -> TsModuleDecl
§fn fold_ts_module_name(&mut self, n: TsModuleName) -> TsModuleName
fn fold_ts_module_name(&mut self, n: TsModuleName) -> TsModuleName
§fn fold_ts_module_ref(&mut self, n: TsModuleRef) -> TsModuleRef
fn fold_ts_module_ref(&mut self, n: TsModuleRef) -> TsModuleRef
§fn fold_ts_namespace_body(&mut self, n: TsNamespaceBody) -> TsNamespaceBody
fn fold_ts_namespace_body(&mut self, n: TsNamespaceBody) -> TsNamespaceBody
§fn fold_ts_namespace_decl(&mut self, n: TsNamespaceDecl) -> TsNamespaceDecl
fn fold_ts_namespace_decl(&mut self, n: TsNamespaceDecl) -> TsNamespaceDecl
§fn fold_ts_namespace_export_decl(
&mut self,
n: TsNamespaceExportDecl
) -> TsNamespaceExportDecl
fn fold_ts_namespace_export_decl( &mut self, n: TsNamespaceExportDecl ) -> TsNamespaceExportDecl
§fn fold_ts_non_null_expr(&mut self, n: TsNonNullExpr) -> TsNonNullExpr
fn fold_ts_non_null_expr(&mut self, n: TsNonNullExpr) -> TsNonNullExpr
§fn fold_ts_optional_type(&mut self, n: TsOptionalType) -> TsOptionalType
fn fold_ts_optional_type(&mut self, n: TsOptionalType) -> TsOptionalType
§fn fold_ts_param_prop(&mut self, n: TsParamProp) -> TsParamProp
fn fold_ts_param_prop(&mut self, n: TsParamProp) -> TsParamProp
§fn fold_ts_param_prop_param(&mut self, n: TsParamPropParam) -> TsParamPropParam
fn fold_ts_param_prop_param(&mut self, n: TsParamPropParam) -> TsParamPropParam
§fn fold_ts_parenthesized_type(
&mut self,
n: TsParenthesizedType
) -> TsParenthesizedType
fn fold_ts_parenthesized_type( &mut self, n: TsParenthesizedType ) -> TsParenthesizedType
§fn fold_ts_property_signature(
&mut self,
n: TsPropertySignature
) -> TsPropertySignature
fn fold_ts_property_signature( &mut self, n: TsPropertySignature ) -> TsPropertySignature
§fn fold_ts_qualified_name(&mut self, n: TsQualifiedName) -> TsQualifiedName
fn fold_ts_qualified_name(&mut self, n: TsQualifiedName) -> TsQualifiedName
§fn fold_ts_rest_type(&mut self, n: TsRestType) -> TsRestType
fn fold_ts_rest_type(&mut self, n: TsRestType) -> TsRestType
§fn fold_ts_satisfies_expr(&mut self, n: TsSatisfiesExpr) -> TsSatisfiesExpr
fn fold_ts_satisfies_expr(&mut self, n: TsSatisfiesExpr) -> TsSatisfiesExpr
§fn fold_ts_setter_signature(
&mut self,
n: TsSetterSignature
) -> TsSetterSignature
fn fold_ts_setter_signature( &mut self, n: TsSetterSignature ) -> TsSetterSignature
§fn fold_ts_this_type(&mut self, n: TsThisType) -> TsThisType
fn fold_ts_this_type(&mut self, n: TsThisType) -> TsThisType
§fn fold_ts_this_type_or_ident(
&mut self,
n: TsThisTypeOrIdent
) -> TsThisTypeOrIdent
fn fold_ts_this_type_or_ident( &mut self, n: TsThisTypeOrIdent ) -> TsThisTypeOrIdent
§fn fold_ts_tpl_lit_type(&mut self, n: TsTplLitType) -> TsTplLitType
fn fold_ts_tpl_lit_type(&mut self, n: TsTplLitType) -> TsTplLitType
§fn fold_ts_tuple_element(&mut self, n: TsTupleElement) -> TsTupleElement
fn fold_ts_tuple_element(&mut self, n: TsTupleElement) -> TsTupleElement
fn fold_ts_tuple_elements( &mut self, n: Vec<TsTupleElement> ) -> Vec<TsTupleElement>
§fn fold_ts_tuple_type(&mut self, n: TsTupleType) -> TsTupleType
fn fold_ts_tuple_type(&mut self, n: TsTupleType) -> TsTupleType
§fn fold_ts_type(&mut self, n: TsType) -> TsType
fn fold_ts_type(&mut self, n: TsType) -> TsType
§fn fold_ts_type_alias_decl(&mut self, n: TsTypeAliasDecl) -> TsTypeAliasDecl
fn fold_ts_type_alias_decl(&mut self, n: TsTypeAliasDecl) -> TsTypeAliasDecl
§fn fold_ts_type_ann(&mut self, n: TsTypeAnn) -> TsTypeAnn
fn fold_ts_type_ann(&mut self, n: TsTypeAnn) -> TsTypeAnn
§fn fold_ts_type_assertion(&mut self, n: TsTypeAssertion) -> TsTypeAssertion
fn fold_ts_type_assertion(&mut self, n: TsTypeAssertion) -> TsTypeAssertion
§fn fold_ts_type_element(&mut self, n: TsTypeElement) -> TsTypeElement
fn fold_ts_type_element(&mut self, n: TsTypeElement) -> TsTypeElement
fn fold_ts_type_elements(&mut self, n: Vec<TsTypeElement>) -> Vec<TsTypeElement>
§fn fold_ts_type_lit(&mut self, n: TsTypeLit) -> TsTypeLit
fn fold_ts_type_lit(&mut self, n: TsTypeLit) -> TsTypeLit
§fn fold_ts_type_operator(&mut self, n: TsTypeOperator) -> TsTypeOperator
fn fold_ts_type_operator(&mut self, n: TsTypeOperator) -> TsTypeOperator
§fn fold_ts_type_operator_op(&mut self, n: TsTypeOperatorOp) -> TsTypeOperatorOp
fn fold_ts_type_operator_op(&mut self, n: TsTypeOperatorOp) -> TsTypeOperatorOp
§fn fold_ts_type_param(&mut self, n: TsTypeParam) -> TsTypeParam
fn fold_ts_type_param(&mut self, n: TsTypeParam) -> TsTypeParam
§fn fold_ts_type_param_decl(&mut self, n: TsTypeParamDecl) -> TsTypeParamDecl
fn fold_ts_type_param_decl(&mut self, n: TsTypeParamDecl) -> TsTypeParamDecl
§fn fold_ts_type_param_instantiation(
&mut self,
n: TsTypeParamInstantiation
) -> TsTypeParamInstantiation
fn fold_ts_type_param_instantiation( &mut self, n: TsTypeParamInstantiation ) -> TsTypeParamInstantiation
fn fold_ts_type_params(&mut self, n: Vec<TsTypeParam>) -> Vec<TsTypeParam>
§fn fold_ts_type_predicate(&mut self, n: TsTypePredicate) -> TsTypePredicate
fn fold_ts_type_predicate(&mut self, n: TsTypePredicate) -> TsTypePredicate
§fn fold_ts_type_query(&mut self, n: TsTypeQuery) -> TsTypeQuery
fn fold_ts_type_query(&mut self, n: TsTypeQuery) -> TsTypeQuery
§fn fold_ts_type_query_expr(&mut self, n: TsTypeQueryExpr) -> TsTypeQueryExpr
fn fold_ts_type_query_expr(&mut self, n: TsTypeQueryExpr) -> TsTypeQueryExpr
§fn fold_ts_type_ref(&mut self, n: TsTypeRef) -> TsTypeRef
fn fold_ts_type_ref(&mut self, n: TsTypeRef) -> TsTypeRef
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
fn fold_ts_union_or_intersection_type( &mut self, n: TsUnionOrIntersectionType ) -> TsUnionOrIntersectionType
§fn fold_ts_union_type(&mut self, n: TsUnionType) -> TsUnionType
fn fold_ts_union_type(&mut self, n: TsUnionType) -> TsUnionType
§fn fold_unary_expr(&mut self, n: UnaryExpr) -> UnaryExpr
fn fold_unary_expr(&mut self, n: UnaryExpr) -> UnaryExpr
§fn fold_unary_op(&mut self, n: UnaryOp) -> UnaryOp
fn fold_unary_op(&mut self, n: UnaryOp) -> UnaryOp
§fn fold_update_expr(&mut self, n: UpdateExpr) -> UpdateExpr
fn fold_update_expr(&mut self, n: UpdateExpr) -> UpdateExpr
§fn fold_update_op(&mut self, n: UpdateOp) -> UpdateOp
fn fold_update_op(&mut self, n: UpdateOp) -> UpdateOp
§fn fold_using_decl(&mut self, n: UsingDecl) -> UsingDecl
fn fold_using_decl(&mut self, n: UsingDecl) -> UsingDecl
§fn fold_var_decl(&mut self, n: VarDecl) -> VarDecl
fn fold_var_decl(&mut self, n: VarDecl) -> VarDecl
§fn fold_var_decl_kind(&mut self, n: VarDeclKind) -> VarDeclKind
fn fold_var_decl_kind(&mut self, n: VarDeclKind) -> VarDeclKind
§fn fold_var_decl_or_expr(&mut self, n: VarDeclOrExpr) -> VarDeclOrExpr
fn fold_var_decl_or_expr(&mut self, n: VarDeclOrExpr) -> VarDeclOrExpr
§fn fold_var_declarator(&mut self, n: VarDeclarator) -> VarDeclarator
fn fold_var_declarator(&mut self, n: VarDeclarator) -> VarDeclarator
fn fold_var_declarators(&mut self, n: Vec<VarDeclarator>) -> Vec<VarDeclarator>
§fn fold_while_stmt(&mut self, n: WhileStmt) -> WhileStmt
fn fold_while_stmt(&mut self, n: WhileStmt) -> WhileStmt
§fn fold_with_stmt(&mut self, n: WithStmt) -> WithStmt
fn fold_with_stmt(&mut self, n: WithStmt) -> WithStmt
§fn fold_yield_expr(&mut self, n: YieldExpr) -> YieldExpr
fn fold_yield_expr(&mut self, n: YieldExpr) -> YieldExpr
§impl<A, B> Fold for Either<A, B>where
A: Fold,
B: Fold,
impl<A, B> Fold for Either<A, B>where
A: Fold,
B: Fold,
§fn fold_absolute_color_base(
&mut self,
n: AbsoluteColorBase
) -> AbsoluteColorBase
fn fold_absolute_color_base( &mut self, n: AbsoluteColorBase ) -> AbsoluteColorBase
§fn fold_alpha_value(&mut self, n: AlphaValue) -> AlphaValue
fn fold_alpha_value(&mut self, n: AlphaValue) -> AlphaValue
§fn fold_an_plus_b(&mut self, n: AnPlusB) -> AnPlusB
fn fold_an_plus_b(&mut self, n: AnPlusB) -> AnPlusB
§fn fold_an_plus_b_notation(&mut self, n: AnPlusBNotation) -> AnPlusBNotation
fn fold_an_plus_b_notation(&mut self, n: AnPlusBNotation) -> AnPlusBNotation
§fn fold_angle(&mut self, n: Angle) -> Angle
fn fold_angle(&mut self, n: Angle) -> Angle
§fn fold_angle_percentage(&mut self, n: AnglePercentage) -> AnglePercentage
fn fold_angle_percentage(&mut self, n: AnglePercentage) -> AnglePercentage
§fn fold_any_namespace(&mut self, n: AnyNamespace) -> AnyNamespace
fn fold_any_namespace(&mut self, n: AnyNamespace) -> AnyNamespace
§fn fold_at_rule(&mut self, n: AtRule) -> AtRule
fn fold_at_rule(&mut self, n: AtRule) -> AtRule
§fn fold_at_rule_name(&mut self, n: AtRuleName) -> AtRuleName
fn fold_at_rule_name(&mut self, n: AtRuleName) -> AtRuleName
§fn fold_at_rule_prelude(&mut self, n: AtRulePrelude) -> AtRulePrelude
fn fold_at_rule_prelude(&mut self, n: AtRulePrelude) -> AtRulePrelude
fn fold_atom(&mut self, n: Atom) -> Atom
§fn fold_attribute_selector(&mut self, n: AttributeSelector) -> AttributeSelector
fn fold_attribute_selector(&mut self, n: AttributeSelector) -> AttributeSelector
§fn fold_attribute_selector_matcher(
&mut self,
n: AttributeSelectorMatcher
) -> AttributeSelectorMatcher
fn fold_attribute_selector_matcher( &mut self, n: AttributeSelectorMatcher ) -> AttributeSelectorMatcher
fn fold_attribute_selector_matcher_value( &mut self, n: AttributeSelectorMatcherValue ) -> AttributeSelectorMatcherValue
§fn fold_attribute_selector_modifier(
&mut self,
n: AttributeSelectorModifier
) -> AttributeSelectorModifier
fn fold_attribute_selector_modifier( &mut self, n: AttributeSelectorModifier ) -> AttributeSelectorModifier
§fn fold_attribute_selector_value(
&mut self,
n: AttributeSelectorValue
) -> AttributeSelectorValue
fn fold_attribute_selector_value( &mut self, n: AttributeSelectorValue ) -> AttributeSelectorValue
§fn fold_calc_operator(&mut self, n: CalcOperator) -> CalcOperator
fn fold_calc_operator(&mut self, n: CalcOperator) -> CalcOperator
§fn fold_calc_operator_type(&mut self, n: CalcOperatorType) -> CalcOperatorType
fn fold_calc_operator_type(&mut self, n: CalcOperatorType) -> CalcOperatorType
§fn fold_calc_product(&mut self, n: CalcProduct) -> CalcProduct
fn fold_calc_product(&mut self, n: CalcProduct) -> CalcProduct
§fn fold_calc_product_or_operator(
&mut self,
n: CalcProductOrOperator
) -> CalcProductOrOperator
fn fold_calc_product_or_operator( &mut self, n: CalcProductOrOperator ) -> CalcProductOrOperator
fn fold_calc_product_or_operators( &mut self, n: Vec<CalcProductOrOperator> ) -> Vec<CalcProductOrOperator>
§fn fold_calc_sum(&mut self, n: CalcSum) -> CalcSum
fn fold_calc_sum(&mut self, n: CalcSum) -> CalcSum
§fn fold_calc_value(&mut self, n: CalcValue) -> CalcValue
fn fold_calc_value(&mut self, n: CalcValue) -> CalcValue
§fn fold_calc_value_or_operator(
&mut self,
n: CalcValueOrOperator
) -> CalcValueOrOperator
fn fold_calc_value_or_operator( &mut self, n: CalcValueOrOperator ) -> CalcValueOrOperator
fn fold_calc_value_or_operators( &mut self, n: Vec<CalcValueOrOperator> ) -> Vec<CalcValueOrOperator>
§fn fold_class_selector(&mut self, n: ClassSelector) -> ClassSelector
fn fold_class_selector(&mut self, n: ClassSelector) -> ClassSelector
§fn fold_cmyk_component(&mut self, n: CmykComponent) -> CmykComponent
fn fold_cmyk_component(&mut self, n: CmykComponent) -> CmykComponent
§fn fold_color(&mut self, n: Color) -> Color
fn fold_color(&mut self, n: Color) -> Color
§fn fold_color_profile_name(&mut self, n: ColorProfileName) -> ColorProfileName
fn fold_color_profile_name(&mut self, n: ColorProfileName) -> ColorProfileName
§fn fold_combinator(&mut self, n: Combinator) -> Combinator
fn fold_combinator(&mut self, n: Combinator) -> Combinator
fn fold_combinator_value(&mut self, n: CombinatorValue) -> CombinatorValue
§fn fold_complex_selector(&mut self, n: ComplexSelector) -> ComplexSelector
fn fold_complex_selector(&mut self, n: ComplexSelector) -> ComplexSelector
§fn fold_complex_selector_children(
&mut self,
n: ComplexSelectorChildren
) -> ComplexSelectorChildren
fn fold_complex_selector_children( &mut self, n: ComplexSelectorChildren ) -> ComplexSelectorChildren
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
fn fold_component_value(&mut self, n: ComponentValue) -> ComponentValue
fn fold_component_values( &mut self, n: Vec<ComponentValue> ) -> Vec<ComponentValue>
§fn fold_compound_selector(&mut self, n: CompoundSelector) -> CompoundSelector
fn fold_compound_selector(&mut self, n: CompoundSelector) -> CompoundSelector
§fn fold_compound_selector_list(
&mut self,
n: CompoundSelectorList
) -> CompoundSelectorList
fn fold_compound_selector_list( &mut self, n: CompoundSelectorList ) -> CompoundSelectorList
fn fold_compound_selectors( &mut self, n: Vec<CompoundSelector> ) -> Vec<CompoundSelector>
§fn fold_container_condition(
&mut self,
n: ContainerCondition
) -> ContainerCondition
fn fold_container_condition( &mut self, n: ContainerCondition ) -> ContainerCondition
§fn fold_container_name(&mut self, n: ContainerName) -> ContainerName
fn fold_container_name(&mut self, n: ContainerName) -> ContainerName
§fn fold_container_query(&mut self, n: ContainerQuery) -> ContainerQuery
fn fold_container_query(&mut self, n: ContainerQuery) -> ContainerQuery
§fn fold_container_query_and(
&mut self,
n: ContainerQueryAnd
) -> ContainerQueryAnd
fn fold_container_query_and( &mut self, n: ContainerQueryAnd ) -> ContainerQueryAnd
§fn fold_container_query_not(
&mut self,
n: ContainerQueryNot
) -> ContainerQueryNot
fn fold_container_query_not( &mut self, n: ContainerQueryNot ) -> ContainerQueryNot
§fn fold_container_query_or(&mut self, n: ContainerQueryOr) -> ContainerQueryOr
fn fold_container_query_or(&mut self, n: ContainerQueryOr) -> ContainerQueryOr
§fn fold_container_query_type(
&mut self,
n: ContainerQueryType
) -> ContainerQueryType
fn fold_container_query_type( &mut self, n: ContainerQueryType ) -> ContainerQueryType
fn fold_container_query_types( &mut self, n: Vec<ContainerQueryType> ) -> Vec<ContainerQueryType>
§fn fold_custom_highlight_name(
&mut self,
n: CustomHighlightName
) -> CustomHighlightName
fn fold_custom_highlight_name( &mut self, n: CustomHighlightName ) -> CustomHighlightName
§fn fold_custom_ident(&mut self, n: CustomIdent) -> CustomIdent
fn fold_custom_ident(&mut self, n: CustomIdent) -> CustomIdent
fn fold_custom_idents(&mut self, n: Vec<CustomIdent>) -> Vec<CustomIdent>
§fn fold_custom_media_query(&mut self, n: CustomMediaQuery) -> CustomMediaQuery
fn fold_custom_media_query(&mut self, n: CustomMediaQuery) -> CustomMediaQuery
§fn fold_custom_media_query_media_type(
&mut self,
n: CustomMediaQueryMediaType
) -> CustomMediaQueryMediaType
fn fold_custom_media_query_media_type( &mut self, n: CustomMediaQueryMediaType ) -> CustomMediaQueryMediaType
§fn fold_custom_property_name(
&mut self,
n: CustomPropertyName
) -> CustomPropertyName
fn fold_custom_property_name( &mut self, n: CustomPropertyName ) -> CustomPropertyName
§fn fold_dashed_ident(&mut self, n: DashedIdent) -> DashedIdent
fn fold_dashed_ident(&mut self, n: DashedIdent) -> DashedIdent
§fn fold_declaration(&mut self, n: Declaration) -> Declaration
fn fold_declaration(&mut self, n: Declaration) -> Declaration
§fn fold_declaration_name(&mut self, n: DeclarationName) -> DeclarationName
fn fold_declaration_name(&mut self, n: DeclarationName) -> DeclarationName
§fn fold_declaration_or_at_rule(
&mut self,
n: DeclarationOrAtRule
) -> DeclarationOrAtRule
fn fold_declaration_or_at_rule( &mut self, n: DeclarationOrAtRule ) -> DeclarationOrAtRule
§fn fold_delimiter(&mut self, n: Delimiter) -> Delimiter
fn fold_delimiter(&mut self, n: Delimiter) -> Delimiter
§fn fold_delimiter_value(&mut self, n: DelimiterValue) -> DelimiterValue
fn fold_delimiter_value(&mut self, n: DelimiterValue) -> DelimiterValue
§fn fold_dimension(&mut self, n: Dimension) -> Dimension
fn fold_dimension(&mut self, n: Dimension) -> Dimension
§fn fold_document_prelude(&mut self, n: DocumentPrelude) -> DocumentPrelude
fn fold_document_prelude(&mut self, n: DocumentPrelude) -> DocumentPrelude
§fn fold_document_prelude_matching_function(
&mut self,
n: DocumentPreludeMatchingFunction
) -> DocumentPreludeMatchingFunction
fn fold_document_prelude_matching_function( &mut self, n: DocumentPreludeMatchingFunction ) -> DocumentPreludeMatchingFunction
fn fold_document_prelude_matching_functions( &mut self, n: Vec<DocumentPreludeMatchingFunction> ) -> Vec<DocumentPreludeMatchingFunction>
§fn fold_extension_name(&mut self, n: ExtensionName) -> ExtensionName
fn fold_extension_name(&mut self, n: ExtensionName) -> ExtensionName
§fn fold_family_name(&mut self, n: FamilyName) -> FamilyName
fn fold_family_name(&mut self, n: FamilyName) -> FamilyName
fn fold_family_names(&mut self, n: Vec<FamilyName>) -> Vec<FamilyName>
§fn fold_flex(&mut self, n: Flex) -> Flex
fn fold_flex(&mut self, n: Flex) -> Flex
§fn fold_font_feature_values_prelude(
&mut self,
n: FontFeatureValuesPrelude
) -> FontFeatureValuesPrelude
fn fold_font_feature_values_prelude( &mut self, n: FontFeatureValuesPrelude ) -> FontFeatureValuesPrelude
§fn fold_forgiving_complex_selector(
&mut self,
n: ForgivingComplexSelector
) -> ForgivingComplexSelector
fn fold_forgiving_complex_selector( &mut self, n: ForgivingComplexSelector ) -> ForgivingComplexSelector
fn fold_forgiving_complex_selectors( &mut self, n: Vec<ForgivingComplexSelector> ) -> Vec<ForgivingComplexSelector>
§fn fold_forgiving_relative_selector(
&mut self,
n: ForgivingRelativeSelector
) -> ForgivingRelativeSelector
fn fold_forgiving_relative_selector( &mut self, n: ForgivingRelativeSelector ) -> ForgivingRelativeSelector
§fn fold_forgiving_relative_selector_list(
&mut self,
n: ForgivingRelativeSelectorList
) -> ForgivingRelativeSelectorList
fn fold_forgiving_relative_selector_list( &mut self, n: ForgivingRelativeSelectorList ) -> ForgivingRelativeSelectorList
fn fold_forgiving_relative_selectors( &mut self, n: Vec<ForgivingRelativeSelector> ) -> Vec<ForgivingRelativeSelector>
§fn fold_forgiving_selector_list(
&mut self,
n: ForgivingSelectorList
) -> ForgivingSelectorList
fn fold_forgiving_selector_list( &mut self, n: ForgivingSelectorList ) -> ForgivingSelectorList
§fn fold_frequency(&mut self, n: Frequency) -> Frequency
fn fold_frequency(&mut self, n: Frequency) -> Frequency
§fn fold_frequency_percentage(
&mut self,
n: FrequencyPercentage
) -> FrequencyPercentage
fn fold_frequency_percentage( &mut self, n: FrequencyPercentage ) -> FrequencyPercentage
§fn fold_function(&mut self, n: Function) -> Function
fn fold_function(&mut self, n: Function) -> Function
§fn fold_function_name(&mut self, n: FunctionName) -> FunctionName
fn fold_function_name(&mut self, n: FunctionName) -> FunctionName
§fn fold_general_enclosed(&mut self, n: GeneralEnclosed) -> GeneralEnclosed
fn fold_general_enclosed(&mut self, n: GeneralEnclosed) -> GeneralEnclosed
§fn fold_hex_color(&mut self, n: HexColor) -> HexColor
fn fold_hex_color(&mut self, n: HexColor) -> HexColor
§fn fold_hue(&mut self, n: Hue) -> Hue
fn fold_hue(&mut self, n: Hue) -> Hue
fn fold_i_32(&mut self, n: i32) -> i32
§fn fold_id_selector(&mut self, n: IdSelector) -> IdSelector
fn fold_id_selector(&mut self, n: IdSelector) -> IdSelector
§fn fold_ident(&mut self, n: Ident) -> Ident
fn fold_ident(&mut self, n: Ident) -> Ident
fn fold_idents(&mut self, n: Vec<Ident>) -> Vec<Ident>
§fn fold_import_conditions(&mut self, n: ImportConditions) -> ImportConditions
fn fold_import_conditions(&mut self, n: ImportConditions) -> ImportConditions
§fn fold_import_href(&mut self, n: ImportHref) -> ImportHref
fn fold_import_href(&mut self, n: ImportHref) -> ImportHref
§fn fold_import_layer_name(&mut self, n: ImportLayerName) -> ImportLayerName
fn fold_import_layer_name(&mut self, n: ImportLayerName) -> ImportLayerName
§fn fold_import_prelude(&mut self, n: ImportPrelude) -> ImportPrelude
fn fold_import_prelude(&mut self, n: ImportPrelude) -> ImportPrelude
§fn fold_important_flag(&mut self, n: ImportantFlag) -> ImportantFlag
fn fold_important_flag(&mut self, n: ImportantFlag) -> ImportantFlag
§fn fold_integer(&mut self, n: Integer) -> Integer
fn fold_integer(&mut self, n: Integer) -> Integer
§fn fold_keyframe_block(&mut self, n: KeyframeBlock) -> KeyframeBlock
fn fold_keyframe_block(&mut self, n: KeyframeBlock) -> KeyframeBlock
§fn fold_keyframe_selector(&mut self, n: KeyframeSelector) -> KeyframeSelector
fn fold_keyframe_selector(&mut self, n: KeyframeSelector) -> KeyframeSelector
fn fold_keyframe_selectors( &mut self, n: Vec<KeyframeSelector> ) -> Vec<KeyframeSelector>
§fn fold_keyframes_name(&mut self, n: KeyframesName) -> KeyframesName
fn fold_keyframes_name(&mut self, n: KeyframesName) -> KeyframesName
§fn fold_keyframes_pseudo_function(
&mut self,
n: KeyframesPseudoFunction
) -> KeyframesPseudoFunction
fn fold_keyframes_pseudo_function( &mut self, n: KeyframesPseudoFunction ) -> KeyframesPseudoFunction
§fn fold_keyframes_pseudo_prefix(
&mut self,
n: KeyframesPseudoPrefix
) -> KeyframesPseudoPrefix
fn fold_keyframes_pseudo_prefix( &mut self, n: KeyframesPseudoPrefix ) -> KeyframesPseudoPrefix
§fn fold_layer_name(&mut self, n: LayerName) -> LayerName
fn fold_layer_name(&mut self, n: LayerName) -> LayerName
§fn fold_layer_name_list(&mut self, n: LayerNameList) -> LayerNameList
fn fold_layer_name_list(&mut self, n: LayerNameList) -> LayerNameList
fn fold_layer_names(&mut self, n: Vec<LayerName>) -> Vec<LayerName>
§fn fold_layer_prelude(&mut self, n: LayerPrelude) -> LayerPrelude
fn fold_layer_prelude(&mut self, n: LayerPrelude) -> LayerPrelude
§fn fold_length(&mut self, n: Length) -> Length
fn fold_length(&mut self, n: Length) -> Length
§fn fold_length_percentage(&mut self, n: LengthPercentage) -> LengthPercentage
fn fold_length_percentage(&mut self, n: LengthPercentage) -> LengthPercentage
§fn fold_list_of_component_values(
&mut self,
n: ListOfComponentValues
) -> ListOfComponentValues
fn fold_list_of_component_values( &mut self, n: ListOfComponentValues ) -> ListOfComponentValues
§fn fold_media_and(&mut self, n: MediaAnd) -> MediaAnd
fn fold_media_and(&mut self, n: MediaAnd) -> MediaAnd
§fn fold_media_condition(&mut self, n: MediaCondition) -> MediaCondition
fn fold_media_condition(&mut self, n: MediaCondition) -> MediaCondition
§fn fold_media_condition_all_type(
&mut self,
n: MediaConditionAllType
) -> MediaConditionAllType
fn fold_media_condition_all_type( &mut self, n: MediaConditionAllType ) -> MediaConditionAllType
fn fold_media_condition_all_types( &mut self, n: Vec<MediaConditionAllType> ) -> Vec<MediaConditionAllType>
§fn fold_media_condition_type(
&mut self,
n: MediaConditionType
) -> MediaConditionType
fn fold_media_condition_type( &mut self, n: MediaConditionType ) -> MediaConditionType
§fn fold_media_condition_without_or(
&mut self,
n: MediaConditionWithoutOr
) -> MediaConditionWithoutOr
fn fold_media_condition_without_or( &mut self, n: MediaConditionWithoutOr ) -> MediaConditionWithoutOr
§fn fold_media_condition_without_or_type(
&mut self,
n: MediaConditionWithoutOrType
) -> MediaConditionWithoutOrType
fn fold_media_condition_without_or_type( &mut self, n: MediaConditionWithoutOrType ) -> MediaConditionWithoutOrType
fn fold_media_condition_without_or_types( &mut self, n: Vec<MediaConditionWithoutOrType> ) -> Vec<MediaConditionWithoutOrType>
§fn fold_media_feature(&mut self, n: MediaFeature) -> MediaFeature
fn fold_media_feature(&mut self, n: MediaFeature) -> MediaFeature
§fn fold_media_feature_boolean(
&mut self,
n: MediaFeatureBoolean
) -> MediaFeatureBoolean
fn fold_media_feature_boolean( &mut self, n: MediaFeatureBoolean ) -> MediaFeatureBoolean
§fn fold_media_feature_name(&mut self, n: MediaFeatureName) -> MediaFeatureName
fn fold_media_feature_name(&mut self, n: MediaFeatureName) -> MediaFeatureName
§fn fold_media_feature_plain(
&mut self,
n: MediaFeaturePlain
) -> MediaFeaturePlain
fn fold_media_feature_plain( &mut self, n: MediaFeaturePlain ) -> MediaFeaturePlain
§fn fold_media_feature_range(
&mut self,
n: MediaFeatureRange
) -> MediaFeatureRange
fn fold_media_feature_range( &mut self, n: MediaFeatureRange ) -> MediaFeatureRange
fn fold_media_feature_range_comparison( &mut self, n: MediaFeatureRangeComparison ) -> MediaFeatureRangeComparison
§fn fold_media_feature_range_interval(
&mut self,
n: MediaFeatureRangeInterval
) -> MediaFeatureRangeInterval
fn fold_media_feature_range_interval( &mut self, n: MediaFeatureRangeInterval ) -> MediaFeatureRangeInterval
§fn fold_media_feature_value(
&mut self,
n: MediaFeatureValue
) -> MediaFeatureValue
fn fold_media_feature_value( &mut self, n: MediaFeatureValue ) -> MediaFeatureValue
§fn fold_media_in_parens(&mut self, n: MediaInParens) -> MediaInParens
fn fold_media_in_parens(&mut self, n: MediaInParens) -> MediaInParens
§fn fold_media_not(&mut self, n: MediaNot) -> MediaNot
fn fold_media_not(&mut self, n: MediaNot) -> MediaNot
§fn fold_media_or(&mut self, n: MediaOr) -> MediaOr
fn fold_media_or(&mut self, n: MediaOr) -> MediaOr
fn fold_media_queries(&mut self, n: Vec<MediaQuery>) -> Vec<MediaQuery>
§fn fold_media_query(&mut self, n: MediaQuery) -> MediaQuery
fn fold_media_query(&mut self, n: MediaQuery) -> MediaQuery
§fn fold_media_query_list(&mut self, n: MediaQueryList) -> MediaQueryList
fn fold_media_query_list(&mut self, n: MediaQueryList) -> MediaQueryList
§fn fold_media_type(&mut self, n: MediaType) -> MediaType
fn fold_media_type(&mut self, n: MediaType) -> MediaType
§fn fold_named_namespace(&mut self, n: NamedNamespace) -> NamedNamespace
fn fold_named_namespace(&mut self, n: NamedNamespace) -> NamedNamespace
§fn fold_namespace(&mut self, n: Namespace) -> Namespace
fn fold_namespace(&mut self, n: Namespace) -> Namespace
§fn fold_namespace_prefix(&mut self, n: NamespacePrefix) -> NamespacePrefix
fn fold_namespace_prefix(&mut self, n: NamespacePrefix) -> NamespacePrefix
§fn fold_namespace_prelude(&mut self, n: NamespacePrelude) -> NamespacePrelude
fn fold_namespace_prelude(&mut self, n: NamespacePrelude) -> NamespacePrelude
§fn fold_namespace_prelude_uri(
&mut self,
n: NamespacePreludeUri
) -> NamespacePreludeUri
fn fold_namespace_prelude_uri( &mut self, n: NamespacePreludeUri ) -> NamespacePreludeUri
§fn fold_nesting_selector(&mut self, n: NestingSelector) -> NestingSelector
fn fold_nesting_selector(&mut self, n: NestingSelector) -> NestingSelector
§fn fold_number(&mut self, n: Number) -> Number
fn fold_number(&mut self, n: Number) -> Number
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
fn fold_page_selector(&mut self, n: PageSelector) -> PageSelector
§fn fold_page_selector_list(&mut self, n: PageSelectorList) -> PageSelectorList
fn fold_page_selector_list(&mut self, n: PageSelectorList) -> PageSelectorList
§fn fold_page_selector_pseudo(
&mut self,
n: PageSelectorPseudo
) -> PageSelectorPseudo
fn fold_page_selector_pseudo( &mut self, n: PageSelectorPseudo ) -> PageSelectorPseudo
fn fold_page_selector_pseudos( &mut self, n: Vec<PageSelectorPseudo> ) -> Vec<PageSelectorPseudo>
§fn fold_page_selector_type(&mut self, n: PageSelectorType) -> PageSelectorType
fn fold_page_selector_type(&mut self, n: PageSelectorType) -> PageSelectorType
fn fold_page_selectors(&mut self, n: Vec<PageSelector>) -> Vec<PageSelector>
§fn fold_percentage(&mut self, n: Percentage) -> Percentage
fn fold_percentage(&mut self, n: Percentage) -> Percentage
§fn fold_pseudo_class_selector(
&mut self,
n: PseudoClassSelector
) -> PseudoClassSelector
fn fold_pseudo_class_selector( &mut self, n: PseudoClassSelector ) -> PseudoClassSelector
§fn fold_pseudo_class_selector_children(
&mut self,
n: PseudoClassSelectorChildren
) -> PseudoClassSelectorChildren
fn fold_pseudo_class_selector_children( &mut self, n: PseudoClassSelectorChildren ) -> PseudoClassSelectorChildren
fn fold_pseudo_class_selector_children_vec( &mut self, n: Vec<PseudoClassSelectorChildren> ) -> Vec<PseudoClassSelectorChildren>
§fn fold_pseudo_element_selector(
&mut self,
n: PseudoElementSelector
) -> PseudoElementSelector
fn fold_pseudo_element_selector( &mut self, n: PseudoElementSelector ) -> PseudoElementSelector
§fn fold_pseudo_element_selector_children(
&mut self,
n: PseudoElementSelectorChildren
) -> PseudoElementSelectorChildren
fn fold_pseudo_element_selector_children( &mut self, n: PseudoElementSelectorChildren ) -> PseudoElementSelectorChildren
fn fold_pseudo_element_selector_children_vec( &mut self, n: Vec<PseudoElementSelectorChildren> ) -> Vec<PseudoElementSelectorChildren>
§fn fold_qualified_rule(&mut self, n: QualifiedRule) -> QualifiedRule
fn fold_qualified_rule(&mut self, n: QualifiedRule) -> QualifiedRule
§fn fold_qualified_rule_prelude(
&mut self,
n: QualifiedRulePrelude
) -> QualifiedRulePrelude
fn fold_qualified_rule_prelude( &mut self, n: QualifiedRulePrelude ) -> QualifiedRulePrelude
§fn fold_query_in_parens(&mut self, n: QueryInParens) -> QueryInParens
fn fold_query_in_parens(&mut self, n: QueryInParens) -> QueryInParens
§fn fold_ratio(&mut self, n: Ratio) -> Ratio
fn fold_ratio(&mut self, n: Ratio) -> Ratio
§fn fold_relative_selector(&mut self, n: RelativeSelector) -> RelativeSelector
fn fold_relative_selector(&mut self, n: RelativeSelector) -> RelativeSelector
§fn fold_relative_selector_list(
&mut self,
n: RelativeSelectorList
) -> RelativeSelectorList
fn fold_relative_selector_list( &mut self, n: RelativeSelectorList ) -> RelativeSelectorList
fn fold_relative_selectors( &mut self, n: Vec<RelativeSelector> ) -> Vec<RelativeSelector>
§fn fold_resolution(&mut self, n: Resolution) -> Resolution
fn fold_resolution(&mut self, n: Resolution) -> Resolution
§fn fold_rule(&mut self, n: Rule) -> Rule
fn fold_rule(&mut self, n: Rule) -> Rule
fn fold_rules(&mut self, n: Vec<Rule>) -> Vec<Rule>
§fn fold_scope_range(&mut self, n: ScopeRange) -> ScopeRange
fn fold_scope_range(&mut self, n: ScopeRange) -> ScopeRange
§fn fold_selector_list(&mut self, n: SelectorList) -> SelectorList
fn fold_selector_list(&mut self, n: SelectorList) -> SelectorList
§fn fold_sequence_of_custom_idents(
&mut self,
n: SequenceOfCustomIdents
) -> SequenceOfCustomIdents
fn fold_sequence_of_custom_idents( &mut self, n: SequenceOfCustomIdents ) -> SequenceOfCustomIdents
§fn fold_simple_block(&mut self, n: SimpleBlock) -> SimpleBlock
fn fold_simple_block(&mut self, n: SimpleBlock) -> SimpleBlock
§fn fold_size_feature(&mut self, n: SizeFeature) -> SizeFeature
fn fold_size_feature(&mut self, n: SizeFeature) -> SizeFeature
§fn fold_size_feature_boolean(
&mut self,
n: SizeFeatureBoolean
) -> SizeFeatureBoolean
fn fold_size_feature_boolean( &mut self, n: SizeFeatureBoolean ) -> SizeFeatureBoolean
§fn fold_size_feature_name(&mut self, n: SizeFeatureName) -> SizeFeatureName
fn fold_size_feature_name(&mut self, n: SizeFeatureName) -> SizeFeatureName
§fn fold_size_feature_plain(&mut self, n: SizeFeaturePlain) -> SizeFeaturePlain
fn fold_size_feature_plain(&mut self, n: SizeFeaturePlain) -> SizeFeaturePlain
§fn fold_size_feature_range(&mut self, n: SizeFeatureRange) -> SizeFeatureRange
fn fold_size_feature_range(&mut self, n: SizeFeatureRange) -> SizeFeatureRange
§fn fold_size_feature_range_comparison(
&mut self,
n: SizeFeatureRangeComparison
) -> SizeFeatureRangeComparison
fn fold_size_feature_range_comparison( &mut self, n: SizeFeatureRangeComparison ) -> SizeFeatureRangeComparison
§fn fold_size_feature_range_interval(
&mut self,
n: SizeFeatureRangeInterval
) -> SizeFeatureRangeInterval
fn fold_size_feature_range_interval( &mut self, n: SizeFeatureRangeInterval ) -> SizeFeatureRangeInterval
§fn fold_size_feature_value(&mut self, n: SizeFeatureValue) -> SizeFeatureValue
fn fold_size_feature_value(&mut self, n: SizeFeatureValue) -> SizeFeatureValue
fn fold_span(&mut self, n: Span) -> Span
§fn fold_str(&mut self, n: Str) -> Str
fn fold_str(&mut self, n: Str) -> Str
§fn fold_style_block(&mut self, n: StyleBlock) -> StyleBlock
fn fold_style_block(&mut self, n: StyleBlock) -> StyleBlock
§fn fold_stylesheet(&mut self, n: Stylesheet) -> Stylesheet
fn fold_stylesheet(&mut self, n: Stylesheet) -> Stylesheet
§fn fold_subclass_selector(&mut self, n: SubclassSelector) -> SubclassSelector
fn fold_subclass_selector(&mut self, n: SubclassSelector) -> SubclassSelector
fn fold_subclass_selectors( &mut self, n: Vec<SubclassSelector> ) -> Vec<SubclassSelector>
§fn fold_supports_and(&mut self, n: SupportsAnd) -> SupportsAnd
fn fold_supports_and(&mut self, n: SupportsAnd) -> SupportsAnd
§fn fold_supports_condition(&mut self, n: SupportsCondition) -> SupportsCondition
fn fold_supports_condition(&mut self, n: SupportsCondition) -> SupportsCondition
§fn fold_supports_condition_type(
&mut self,
n: SupportsConditionType
) -> SupportsConditionType
fn fold_supports_condition_type( &mut self, n: SupportsConditionType ) -> SupportsConditionType
fn fold_supports_condition_types( &mut self, n: Vec<SupportsConditionType> ) -> Vec<SupportsConditionType>
§fn fold_supports_feature(&mut self, n: SupportsFeature) -> SupportsFeature
fn fold_supports_feature(&mut self, n: SupportsFeature) -> SupportsFeature
§fn fold_supports_in_parens(&mut self, n: SupportsInParens) -> SupportsInParens
fn fold_supports_in_parens(&mut self, n: SupportsInParens) -> SupportsInParens
§fn fold_supports_not(&mut self, n: SupportsNot) -> SupportsNot
fn fold_supports_not(&mut self, n: SupportsNot) -> SupportsNot
§fn fold_supports_or(&mut self, n: SupportsOr) -> SupportsOr
fn fold_supports_or(&mut self, n: SupportsOr) -> SupportsOr
§fn fold_tag_name_selector(&mut self, n: TagNameSelector) -> TagNameSelector
fn fold_tag_name_selector(&mut self, n: TagNameSelector) -> TagNameSelector
§fn fold_time(&mut self, n: Time) -> Time
fn fold_time(&mut self, n: Time) -> Time
§fn fold_time_percentage(&mut self, n: TimePercentage) -> TimePercentage
fn fold_time_percentage(&mut self, n: TimePercentage) -> TimePercentage
fn fold_token(&mut self, n: Token) -> Token
§fn fold_token_and_span(&mut self, n: TokenAndSpan) -> TokenAndSpan
fn fold_token_and_span(&mut self, n: TokenAndSpan) -> TokenAndSpan
§fn fold_type_selector(&mut self, n: TypeSelector) -> TypeSelector
fn fold_type_selector(&mut self, n: TypeSelector) -> TypeSelector
§fn fold_unicode_range(&mut self, n: UnicodeRange) -> UnicodeRange
fn fold_unicode_range(&mut self, n: UnicodeRange) -> UnicodeRange
§fn fold_universal_selector(&mut self, n: UniversalSelector) -> UniversalSelector
fn fold_universal_selector(&mut self, n: UniversalSelector) -> UniversalSelector
§fn fold_unknown_dimension(&mut self, n: UnknownDimension) -> UnknownDimension
fn fold_unknown_dimension(&mut self, n: UnknownDimension) -> UnknownDimension
§fn fold_url(&mut self, n: Url) -> Url
fn fold_url(&mut self, n: Url) -> Url
§fn fold_url_modifier(&mut self, n: UrlModifier) -> UrlModifier
fn fold_url_modifier(&mut self, n: UrlModifier) -> UrlModifier
fn fold_url_modifiers(&mut self, n: Vec<UrlModifier>) -> Vec<UrlModifier>
§fn fold_url_value(&mut self, n: UrlValue) -> UrlValue
fn fold_url_value(&mut self, n: UrlValue) -> UrlValue
§fn fold_url_value_raw(&mut self, n: UrlValueRaw) -> UrlValueRaw
fn fold_url_value_raw(&mut self, n: UrlValueRaw) -> UrlValueRaw
§fn fold_wq_name(&mut self, n: WqName) -> WqName
fn fold_wq_name(&mut self, n: WqName) -> WqName
source§impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>
impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>
source§fn from(either: Either<A, B>) -> EitherOrBoth<A, B>
fn from(either: Either<A, B>) -> EitherOrBoth<A, B>
source§impl<L, R> From<Result<R, L>> for Either<L, R>
impl<L, R> From<Result<R, L>> for Either<L, R>
Convert from Result
to Either
with Ok => Right
and Err => Left
.
§impl<L, R> IndexedParallelIterator for Either<L, R>where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,
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>>::Resultwhere
C: Consumer<<Either<L, R> as ParallelIterator>::Item>,
fn drive<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: Consumer<<Either<L, R> as ParallelIterator>::Item>,
§fn len(&self) -> usize
fn len(&self) -> usize
§fn with_producer<CB>(
self,
callback: CB
) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Outputwhere
CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,
fn with_producer<CB>(
self,
callback: CB
) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Outputwhere
CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,
§fn collect_into_vec(self, target: &mut Vec<Self::Item>)
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
§fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)
fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)
§fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
(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. Read more§fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
Zip
, but requires that both iterators have the same length. Read more§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>,
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>,
§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>,
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>,
§fn chunks(self, chunk_size: usize) -> Chunks<Self>
fn chunks(self, chunk_size: usize) -> Chunks<Self>
§fn fold_chunks<T, ID, F>(
self,
chunk_size: usize,
identity: ID,
fold_op: F
) -> FoldChunks<Self, ID, F>
fn fold_chunks<T, ID, F>( self, chunk_size: usize, identity: ID, fold_op: F ) -> FoldChunks<Self, ID, F>
§fn fold_chunks_with<T, F>(
self,
chunk_size: usize,
init: T,
fold_op: F
) -> FoldChunksWith<Self, T, F>
fn fold_chunks_with<T, F>( self, chunk_size: usize, init: T, fold_op: F ) -> FoldChunksWith<Self, T, F>
§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
with those of
another. Read more§fn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
ParallelIterator
are equal to those of another§fn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
ParallelIterator
are unequal to those of another§fn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are lexicographically less than those of another.§fn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are less or equal to those of another.§fn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are lexicographically greater than those of another.§fn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are less or equal to those of another.§fn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
§fn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read more§fn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements. Read more§fn position_any<P>(self, predicate: P) -> Option<usize>
fn position_any<P>(self, predicate: P) -> Option<usize>
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. Read more§fn position_first<P>(self, predicate: P) -> Option<usize>
fn position_first<P>(self, predicate: P) -> Option<usize>
§fn position_last<P>(self, predicate: P) -> Option<usize>
fn position_last<P>(self, predicate: P) -> Option<usize>
§fn positions<P>(self, predicate: P) -> Positions<Self, P>
fn positions<P>(self, predicate: P) -> Positions<Self, P>
§fn rev(self) -> Rev<Self>
fn rev(self) -> Rev<Self>
§fn with_min_len(self, min: usize) -> MinLen<Self>
fn with_min_len(self, min: usize) -> MinLen<Self>
§fn with_max_len(self, max: usize) -> MaxLen<Self>
fn with_max_len(self, max: usize) -> MaxLen<Self>
with_min_len()
.
For example, given min=10 and max=15, a length of 16 will not be
split any further. Read moresource§impl<L, R> Into<Result<R, L>> for Either<L, R>
impl<L, R> Into<Result<R, L>> for Either<L, R>
Convert from Either
to Result
with Right => Ok
and Left => Err
.
source§impl<L, R> Iterator for Either<L, R>
impl<L, R> Iterator for Either<L, R>
Either<L, R>
is an iterator if both L
and R
are iterators.
source§fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
source§fn count(self) -> usize
fn count(self) -> usize
source§fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
source§fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
n
th element of the iterator. Read moresource§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
source§fn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
fn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read moresource§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)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. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
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. Read moresource§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>,
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>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)source§impl<L, R> Ord for Either<L, R>
impl<L, R> Ord for Either<L, R>
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
§impl<L, R, T> ParallelExtend<T> for Either<L, R>where
L: ParallelExtend<T>,
R: ParallelExtend<T>,
T: Send,
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>,
fn par_extend<I>(&mut self, par_iter: I)where
I: IntoParallelIterator<Item = T>,
par_iter
. Read more§impl<L, R> ParallelIterator for Either<L, R>where
L: ParallelIterator,
R: ParallelIterator<Item = <L as ParallelIterator>::Item>,
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
type Item = <L as ParallelIterator>::Item
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>>::Resultwhere
C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,
fn drive_unindexed<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,
§fn opt_len(&self) -> Option<usize>
fn opt_len(&self) -> Option<usize>
§fn for_each<OP>(self, op: OP)
fn for_each<OP>(self, op: OP)
OP
on each item produced by the iterator, in parallel. Read more§fn for_each_with<OP, T>(self, init: T, op: OP)
fn for_each_with<OP, T>(self, init: T, op: OP)
§fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
OP
on a value returned by init
with each item produced by
the iterator, in parallel. Read more§fn try_for_each<OP, R>(self, op: OP) -> R
fn try_for_each<OP, R>(self, op: OP) -> R
OP
on each item produced by the iterator, in parallel. Read more§fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
OP
on the given init
value with each item
produced by the iterator, in parallel. Read more§fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
OP
on a value returned by init
with each item
produced by the iterator, in parallel. Read more§fn map<F, R>(self, map_op: F) -> Map<Self, F>
fn map<F, R>(self, map_op: F) -> Map<Self, F>
map_op
to each item of this iterator, producing a new
iterator with the results. Read more§fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
map_op
to the given init
value with each item of this
iterator, producing a new iterator with the results. Read more§fn map_init<F, INIT, T, R>(
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F>
fn map_init<F, INIT, T, R>( self, init: INIT, map_op: F ) -> MapInit<Self, INIT, F>
map_op
to a value returned by init
with each item of this
iterator, producing a new iterator with the results. Read more§fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
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. Read more§fn update<F>(self, update_op: F) -> Update<Self, F>
fn update<F>(self, update_op: F) -> Update<Self, F>
§fn filter<P>(self, filter_op: P) -> Filter<Self, P>
fn filter<P>(self, filter_op: P) -> Filter<Self, P>
filter_op
to each item of this iterator, producing a new
iterator with only the items that gave true
results. Read more§fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
filter_op
to each item of this iterator to get an Option
,
producing a new iterator with only the items from Some
results. Read more§fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
map_op
to each item of this iterator to get nested parallel iterators,
producing a new parallel iterator that flattens these back into one. Read more§fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
map_op
to each item of this iterator to get nested serial iterators,
producing a new parallel iterator that flattens these back into one. Read more§fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
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). Read more§fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
op
.
If the iterator is empty, None
is returned; otherwise,
Some
is returned. Read more§fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
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. Read more§fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
fold_op
to the given init
value with each item of this
iterator, finally producing the value for further use. Read more§fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F>
fn try_fold<T, R, ID, F>( self, identity: ID, fold_op: F ) -> TryFold<Self, R, ID, F>
§fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
init
value. Read more§fn min_by<F>(self, f: F) -> Option<Self::Item>
fn min_by<F>(self, f: F) -> Option<Self::Item>
None
is
returned; otherwise, Some(min)
is returned. Read more§fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
None
is returned;
otherwise, Some(item)
is returned. Read more§fn max_by<F>(self, f: F) -> Option<Self::Item>
fn max_by<F>(self, f: F) -> Option<Self::Item>
None
is
returned; otherwise, Some(max)
is returned. Read more§fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
None
is returned;
otherwise, Some(item)
is returned. Read more§fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
§fn find_any<P>(self, predicate: P) -> Option<Self::Item>
fn find_any<P>(self, predicate: P) -> Option<Self::Item>
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. Read more§fn find_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_first<P>(self, predicate: P) -> Option<Self::Item>
§fn find_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_last<P>(self, predicate: P) -> Option<Self::Item>
§fn find_map_any<P, R>(self, predicate: P) -> Option<R>
fn find_map_any<P, R>(self, predicate: P) -> Option<R>
§fn find_map_first<P, R>(self, predicate: P) -> Option<R>
fn find_map_first<P, R>(self, predicate: P) -> Option<R>
§fn find_map_last<P, R>(self, predicate: P) -> Option<R>
fn find_map_last<P, R>(self, predicate: P) -> Option<R>
§fn any<P>(self, predicate: P) -> bool
fn any<P>(self, predicate: P) -> bool
§fn all<P>(self, predicate: P) -> bool
fn all<P>(self, predicate: P) -> bool
§fn while_some<T>(self) -> WhileSome<Self>
fn while_some<T>(self) -> WhileSome<Self>
Some
items of this iterator, halting
as soon as any None
is found. Read more§fn panic_fuse(self) -> PanicFuse<Self>
fn panic_fuse(self) -> PanicFuse<Self>
§fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
ParallelExtend
containers. Read more§fn partition<A, B, P>(self, predicate: P) -> (A, B)
fn partition<A, B, P>(self, predicate: P) -> (A, B)
ParallelExtend
containers. Items for which the predicate
returns
true go into the first container, and the rest go into the second. Read more§fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
ParallelExtend
containers. Either::Left
items go into
the first container, and Either::Right
items go into the second. Read more§fn take_any(self, n: usize) -> TakeAny<Self>
fn take_any(self, n: usize) -> TakeAny<Self>
n
elements from anywhere in the original iterator. Read more§fn skip_any(self, n: usize) -> SkipAny<Self>
fn skip_any(self, n: usize) -> SkipAny<Self>
n
elements from anywhere in the original iterator. Read more§fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>
fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>
predicate
returns false
. Read moresource§impl<L, R> PartialEq for Either<L, R>
impl<L, R> PartialEq for Either<L, R>
source§impl<L, R> PartialOrd for Either<L, R>where
L: PartialOrd,
R: PartialOrd,
impl<L, R> PartialOrd for Either<L, R>where
L: PartialOrd,
R: PartialOrd,
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<L, R> Read for Either<L, R>
impl<L, R> Read for Either<L, R>
Either<L, R>
implements Read
if both L
and R
do.
Requires crate feature "use_std"
source§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
source§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf
. Read moresource§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf
. Read moresource§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf
. Read more1.36.0 · source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read
, except that it reads into a slice of buffers. Read moresource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)source§fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)source§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)cursor
. Read more1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Read
. Read moresource§impl<L, R> Seek for Either<L, R>
impl<L, R> Seek for Either<L, R>
Either<L, R>
implements Seek
if both L
and R
do.
Requires crate feature "use_std"
source§fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
1.55.0 · source§fn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), Error>
source§fn stream_len(&mut self) -> Result<u64, Error>
fn stream_len(&mut self) -> Result<u64, Error>
seek_stream_len
)§impl<A, B> Visit for Either<A, B>
impl<A, B> Visit for Either<A, B>
§fn visit_accessibility(&mut self, n: &Accessibility)
fn visit_accessibility(&mut self, n: &Accessibility)
§fn visit_array_lit(&mut self, n: &ArrayLit)
fn visit_array_lit(&mut self, n: &ArrayLit)
§fn visit_array_pat(&mut self, n: &ArrayPat)
fn visit_array_pat(&mut self, n: &ArrayPat)
§fn visit_arrow_expr(&mut self, n: &ArrowExpr)
fn visit_arrow_expr(&mut self, n: &ArrowExpr)
§fn visit_assign_expr(&mut self, n: &AssignExpr)
fn visit_assign_expr(&mut self, n: &AssignExpr)
§fn visit_assign_op(&mut self, n: &AssignOp)
fn visit_assign_op(&mut self, n: &AssignOp)
§fn visit_assign_pat(&mut self, n: &AssignPat)
fn visit_assign_pat(&mut self, n: &AssignPat)
§fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
§fn visit_assign_prop(&mut self, n: &AssignProp)
fn visit_assign_prop(&mut self, n: &AssignProp)
§fn visit_assign_target(&mut self, n: &AssignTarget)
fn visit_assign_target(&mut self, n: &AssignTarget)
§fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)
fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)
fn visit_atom(&mut self, n: &Atom)
§fn visit_auto_accessor(&mut self, n: &AutoAccessor)
fn visit_auto_accessor(&mut self, n: &AutoAccessor)
§fn visit_await_expr(&mut self, n: &AwaitExpr)
fn visit_await_expr(&mut self, n: &AwaitExpr)
§fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int_value(&mut self, n: &BigInt)
§fn visit_bin_expr(&mut self, n: &BinExpr)
fn visit_bin_expr(&mut self, n: &BinExpr)
§fn visit_binary_op(&mut self, n: &BinaryOp)
fn visit_binary_op(&mut self, n: &BinaryOp)
§fn visit_binding_ident(&mut self, n: &BindingIdent)
fn visit_binding_ident(&mut self, n: &BindingIdent)
§fn visit_block_stmt(&mut self, n: &BlockStmt)
fn visit_block_stmt(&mut self, n: &BlockStmt)
§fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
§fn visit_bool(&mut self, n: &Bool)
fn visit_bool(&mut self, n: &Bool)
§fn visit_break_stmt(&mut self, n: &BreakStmt)
fn visit_break_stmt(&mut self, n: &BreakStmt)
§fn visit_call_expr(&mut self, n: &CallExpr)
fn visit_call_expr(&mut self, n: &CallExpr)
§fn visit_callee(&mut self, n: &Callee)
fn visit_callee(&mut self, n: &Callee)
§fn visit_catch_clause(&mut self, n: &CatchClause)
fn visit_catch_clause(&mut self, n: &CatchClause)
§fn visit_class(&mut self, n: &Class)
fn visit_class(&mut self, n: &Class)
§fn visit_class_decl(&mut self, n: &ClassDecl)
fn visit_class_decl(&mut self, n: &ClassDecl)
§fn visit_class_expr(&mut self, n: &ClassExpr)
fn visit_class_expr(&mut self, n: &ClassExpr)
§fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_members(&mut self, n: &[ClassMember])
§fn visit_class_method(&mut self, n: &ClassMethod)
fn visit_class_method(&mut self, n: &ClassMethod)
§fn visit_class_prop(&mut self, n: &ClassProp)
fn visit_class_prop(&mut self, n: &ClassProp)
§fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
§fn visit_cond_expr(&mut self, n: &CondExpr)
fn visit_cond_expr(&mut self, n: &CondExpr)
§fn visit_constructor(&mut self, n: &Constructor)
fn visit_constructor(&mut self, n: &Constructor)
§fn visit_continue_stmt(&mut self, n: &ContinueStmt)
fn visit_continue_stmt(&mut self, n: &ContinueStmt)
§fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
§fn visit_decl(&mut self, n: &Decl)
fn visit_decl(&mut self, n: &Decl)
§fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorators(&mut self, n: &[Decorator])
§fn visit_default_decl(&mut self, n: &DefaultDecl)
fn visit_default_decl(&mut self, n: &DefaultDecl)
§fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
§fn visit_empty_stmt(&mut self, n: &EmptyStmt)
fn visit_empty_stmt(&mut self, n: &EmptyStmt)
§fn visit_export_all(&mut self, n: &ExportAll)
fn visit_export_all(&mut self, n: &ExportAll)
§fn visit_export_decl(&mut self, n: &ExportDecl)
fn visit_export_decl(&mut self, n: &ExportDecl)
§fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
§fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
§fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
§fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
§fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
§fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])
§fn visit_expr(&mut self, n: &Expr)
fn visit_expr(&mut self, n: &Expr)
§fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])
§fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_exprs(&mut self, n: &[Box<Expr>])
§fn visit_fn_decl(&mut self, n: &FnDecl)
fn visit_fn_decl(&mut self, n: &FnDecl)
§fn visit_fn_expr(&mut self, n: &FnExpr)
fn visit_fn_expr(&mut self, n: &FnExpr)
§fn visit_for_head(&mut self, n: &ForHead)
fn visit_for_head(&mut self, n: &ForHead)
§fn visit_for_in_stmt(&mut self, n: &ForInStmt)
fn visit_for_in_stmt(&mut self, n: &ForInStmt)
§fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
§fn visit_for_stmt(&mut self, n: &ForStmt)
fn visit_for_stmt(&mut self, n: &ForStmt)
§fn visit_function(&mut self, n: &Function)
fn visit_function(&mut self, n: &Function)
§fn visit_getter_prop(&mut self, n: &GetterProp)
fn visit_getter_prop(&mut self, n: &GetterProp)
§fn visit_ident(&mut self, n: &Ident)
fn visit_ident(&mut self, n: &Ident)
§fn visit_if_stmt(&mut self, n: &IfStmt)
fn visit_if_stmt(&mut self, n: &IfStmt)
§fn visit_import(&mut self, n: &Import)
fn visit_import(&mut self, n: &Import)
§fn visit_import_decl(&mut self, n: &ImportDecl)
fn visit_import_decl(&mut self, n: &ImportDecl)
§fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
§fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_phase(&mut self, n: &ImportPhase)
§fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])
§fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
§fn visit_invalid(&mut self, n: &Invalid)
fn visit_invalid(&mut self, n: &Invalid)
§fn visit_jsx_attr(&mut self, n: &JSXAttr)
fn visit_jsx_attr(&mut self, n: &JSXAttr)
§fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
§fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])
§fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
§fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
§fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
§fn visit_jsx_element(&mut self, n: &JSXElement)
fn visit_jsx_element(&mut self, n: &JSXElement)
§fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])
§fn visit_jsx_element_name(&mut self, n: &JSXElementName)
fn visit_jsx_element_name(&mut self, n: &JSXElementName)
§fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
§fn visit_jsx_expr(&mut self, n: &JSXExpr)
fn visit_jsx_expr(&mut self, n: &JSXExpr)
§fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
§fn visit_jsx_fragment(&mut self, n: &JSXFragment)
fn visit_jsx_fragment(&mut self, n: &JSXFragment)
§fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
§fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
§fn visit_jsx_object(&mut self, n: &JSXObject)
fn visit_jsx_object(&mut self, n: &JSXObject)
§fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
§fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
§fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
§fn visit_jsx_text(&mut self, n: &JSXText)
fn visit_jsx_text(&mut self, n: &JSXText)
§fn visit_key(&mut self, n: &Key)
fn visit_key(&mut self, n: &Key)
§fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
§fn visit_key_value_prop(&mut self, n: &KeyValueProp)
fn visit_key_value_prop(&mut self, n: &KeyValueProp)
§fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
§fn visit_lit(&mut self, n: &Lit)
fn visit_lit(&mut self, n: &Lit)
§fn visit_member_expr(&mut self, n: &MemberExpr)
fn visit_member_expr(&mut self, n: &MemberExpr)
§fn visit_member_prop(&mut self, n: &MemberProp)
fn visit_member_prop(&mut self, n: &MemberProp)
§fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
§fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
§fn visit_method_kind(&mut self, n: &MethodKind)
fn visit_method_kind(&mut self, n: &MethodKind)
§fn visit_method_prop(&mut self, n: &MethodProp)
fn visit_method_prop(&mut self, n: &MethodProp)
§fn visit_module(&mut self, n: &Module)
fn visit_module(&mut self, n: &Module)
§fn visit_module_decl(&mut self, n: &ModuleDecl)
fn visit_module_decl(&mut self, n: &ModuleDecl)
§fn visit_module_export_name(&mut self, n: &ModuleExportName)
fn visit_module_export_name(&mut self, n: &ModuleExportName)
§fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_items(&mut self, n: &[ModuleItem])
§fn visit_named_export(&mut self, n: &NamedExport)
fn visit_named_export(&mut self, n: &NamedExport)
§fn visit_new_expr(&mut self, n: &NewExpr)
fn visit_new_expr(&mut self, n: &NewExpr)
§fn visit_null(&mut self, n: &Null)
fn visit_null(&mut self, n: &Null)
§fn visit_number(&mut self, n: &Number)
fn visit_number(&mut self, n: &Number)
§fn visit_object_lit(&mut self, n: &ObjectLit)
fn visit_object_lit(&mut self, n: &ObjectLit)
§fn visit_object_pat(&mut self, n: &ObjectPat)
fn visit_object_pat(&mut self, n: &ObjectPat)
§fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])
fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)
fn visit_opt_atom(&mut self, n: Option<&Atom>)
fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)
§fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)
§fn visit_opt_chain_base(&mut self, n: &OptChainBase)
fn visit_opt_chain_base(&mut self, n: &OptChainBase)
§fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
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)
fn visit_param(&mut self, n: &Param)
§fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_props(&mut self, n: &[ParamOrTsParamProp])
fn visit_params(&mut self, n: &[Param])
§fn visit_paren_expr(&mut self, n: &ParenExpr)
fn visit_paren_expr(&mut self, n: &ParenExpr)
§fn visit_pat(&mut self, n: &Pat)
fn visit_pat(&mut self, n: &Pat)
fn visit_pats(&mut self, n: &[Pat])
§fn visit_private_method(&mut self, n: &PrivateMethod)
fn visit_private_method(&mut self, n: &PrivateMethod)
§fn visit_private_name(&mut self, n: &PrivateName)
fn visit_private_name(&mut self, n: &PrivateName)
§fn visit_private_prop(&mut self, n: &PrivateProp)
fn visit_private_prop(&mut self, n: &PrivateProp)
§fn visit_program(&mut self, n: &Program)
fn visit_program(&mut self, n: &Program)
§fn visit_prop(&mut self, n: &Prop)
fn visit_prop(&mut self, n: &Prop)
§fn visit_prop_name(&mut self, n: &PropName)
fn visit_prop_name(&mut self, n: &PropName)
§fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])
§fn visit_regex(&mut self, n: &Regex)
fn visit_regex(&mut self, n: &Regex)
§fn visit_reserved_unused(&mut self, n: &ReservedUnused)
fn visit_reserved_unused(&mut self, n: &ReservedUnused)
§fn visit_rest_pat(&mut self, n: &RestPat)
fn visit_rest_pat(&mut self, n: &RestPat)
§fn visit_return_stmt(&mut self, n: &ReturnStmt)
fn visit_return_stmt(&mut self, n: &ReturnStmt)
§fn visit_script(&mut self, n: &Script)
fn visit_script(&mut self, n: &Script)
§fn visit_seq_expr(&mut self, n: &SeqExpr)
fn visit_seq_expr(&mut self, n: &SeqExpr)
§fn visit_setter_prop(&mut self, n: &SetterProp)
fn visit_setter_prop(&mut self, n: &SetterProp)
§fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)
fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)
fn visit_span(&mut self, n: &Span)
§fn visit_spread_element(&mut self, n: &SpreadElement)
fn visit_spread_element(&mut self, n: &SpreadElement)
§fn visit_static_block(&mut self, n: &StaticBlock)
fn visit_static_block(&mut self, n: &StaticBlock)
§fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmts(&mut self, n: &[Stmt])
§fn visit_str(&mut self, n: &Str)
fn visit_str(&mut self, n: &Str)
§fn visit_super(&mut self, n: &Super)
fn visit_super(&mut self, n: &Super)
§fn visit_super_prop(&mut self, n: &SuperProp)
fn visit_super_prop(&mut self, n: &SuperProp)
§fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
§fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_cases(&mut self, n: &[SwitchCase])
§fn visit_switch_stmt(&mut self, n: &SwitchStmt)
fn visit_switch_stmt(&mut self, n: &SwitchStmt)
§fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
§fn visit_this_expr(&mut self, n: &ThisExpr)
fn visit_this_expr(&mut self, n: &ThisExpr)
§fn visit_throw_stmt(&mut self, n: &ThrowStmt)
fn visit_throw_stmt(&mut self, n: &ThrowStmt)
§fn visit_tpl(&mut self, n: &Tpl)
fn visit_tpl(&mut self, n: &Tpl)
§fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_elements(&mut self, n: &[TplElement])
§fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
§fn visit_try_stmt(&mut self, n: &TryStmt)
fn visit_try_stmt(&mut self, n: &TryStmt)
§fn visit_ts_array_type(&mut self, n: &TsArrayType)
fn visit_ts_array_type(&mut self, n: &TsArrayType)
§fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
§fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
§fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
§fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
§fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
§fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
§fn visit_ts_entity_name(&mut self, n: &TsEntityName)
fn visit_ts_entity_name(&mut self, n: &TsEntityName)
§fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
§fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
§fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])
§fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
§fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])
§fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
§fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
§fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_params(&mut self, n: &[TsFnParam])
§fn visit_ts_fn_type(&mut self, n: &TsFnType)
fn visit_ts_fn_type(&mut self, n: &TsFnType)
§fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
§fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
§fn visit_ts_import_type(&mut self, n: &TsImportType)
fn visit_ts_import_type(&mut self, n: &TsImportType)
§fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
§fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
§fn visit_ts_infer_type(&mut self, n: &TsInferType)
fn visit_ts_infer_type(&mut self, n: &TsInferType)
§fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
§fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
§fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
§fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
§fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
§fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
§fn visit_ts_lit(&mut self, n: &TsLit)
fn visit_ts_lit(&mut self, n: &TsLit)
§fn visit_ts_lit_type(&mut self, n: &TsLitType)
fn visit_ts_lit_type(&mut self, n: &TsLitType)
§fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
§fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
§fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
§fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
§fn visit_ts_module_name(&mut self, n: &TsModuleName)
fn visit_ts_module_name(&mut self, n: &TsModuleName)
§fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
§fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
§fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
§fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
§fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
§fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
§fn visit_ts_param_prop(&mut self, n: &TsParamProp)
fn visit_ts_param_prop(&mut self, n: &TsParamProp)
§fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
§fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
§fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
§fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
§fn visit_ts_rest_type(&mut self, n: &TsRestType)
fn visit_ts_rest_type(&mut self, n: &TsRestType)
§fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)
fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)
§fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
§fn visit_ts_this_type(&mut self, n: &TsThisType)
fn visit_ts_this_type(&mut self, n: &TsThisType)
§fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
§fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
§fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])
§fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
§fn visit_ts_type(&mut self, n: &TsType)
fn visit_ts_type(&mut self, n: &TsType)
§fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
§fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
§fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
§fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])
§fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
§fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
§fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
§fn visit_ts_type_param(&mut self, n: &TsTypeParam)
fn visit_ts_type_param(&mut self, n: &TsTypeParam)
§fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
§fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_params(&mut self, n: &[TsTypeParam])
§fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
§fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
§fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
§fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_types(&mut self, n: &[Box<TsType>])
§fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
§fn visit_ts_union_type(&mut self, n: &TsUnionType)
fn visit_ts_union_type(&mut self, n: &TsUnionType)
§fn visit_unary_expr(&mut self, n: &UnaryExpr)
fn visit_unary_expr(&mut self, n: &UnaryExpr)
§fn visit_unary_op(&mut self, n: &UnaryOp)
fn visit_unary_op(&mut self, n: &UnaryOp)
§fn visit_update_expr(&mut self, n: &UpdateExpr)
fn visit_update_expr(&mut self, n: &UpdateExpr)
§fn visit_update_op(&mut self, n: &UpdateOp)
fn visit_update_op(&mut self, n: &UpdateOp)
§fn visit_using_decl(&mut self, n: &UsingDecl)
fn visit_using_decl(&mut self, n: &UsingDecl)
§fn visit_var_decl(&mut self, n: &VarDecl)
fn visit_var_decl(&mut self, n: &VarDecl)
§fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
§fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
§fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarators(&mut self, n: &[VarDeclarator])
§fn visit_while_stmt(&mut self, n: &WhileStmt)
fn visit_while_stmt(&mut self, n: &WhileStmt)
§fn visit_with_stmt(&mut self, n: &WithStmt)
fn visit_with_stmt(&mut self, n: &WithStmt)
§fn visit_yield_expr(&mut self, n: &YieldExpr)
fn visit_yield_expr(&mut self, n: &YieldExpr)
§impl<A, B> Visit for Either<A, B>where
A: Visit,
B: Visit,
impl<A, B> Visit for Either<A, B>where
A: Visit,
B: Visit,
§fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)
fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)
§fn visit_alpha_value(&mut self, n: &AlphaValue)
fn visit_alpha_value(&mut self, n: &AlphaValue)
§fn visit_an_plus_b(&mut self, n: &AnPlusB)
fn visit_an_plus_b(&mut self, n: &AnPlusB)
§fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)
fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)
§fn visit_angle(&mut self, n: &Angle)
fn visit_angle(&mut self, n: &Angle)
§fn visit_angle_percentage(&mut self, n: &AnglePercentage)
fn visit_angle_percentage(&mut self, n: &AnglePercentage)
§fn visit_any_namespace(&mut self, n: &AnyNamespace)
fn visit_any_namespace(&mut self, n: &AnyNamespace)
§fn visit_at_rule(&mut self, n: &AtRule)
fn visit_at_rule(&mut self, n: &AtRule)
§fn visit_at_rule_name(&mut self, n: &AtRuleName)
fn visit_at_rule_name(&mut self, n: &AtRuleName)
§fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)
fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)
fn visit_atom(&mut self, n: &Atom)
§fn visit_attribute_selector(&mut self, n: &AttributeSelector)
fn visit_attribute_selector(&mut self, n: &AttributeSelector)
§fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)
fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)
fn visit_attribute_selector_matcher_value( &mut self, n: &AttributeSelectorMatcherValue )
§fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)
fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)
§fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)
fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)
§fn visit_calc_operator(&mut self, n: &CalcOperator)
fn visit_calc_operator(&mut self, n: &CalcOperator)
§fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)
fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)
§fn visit_calc_product(&mut self, n: &CalcProduct)
fn visit_calc_product(&mut self, n: &CalcProduct)
§fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)
fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)
fn visit_calc_product_or_operators(&mut self, n: &[CalcProductOrOperator])
§fn visit_calc_sum(&mut self, n: &CalcSum)
fn visit_calc_sum(&mut self, n: &CalcSum)
§fn visit_calc_value(&mut self, n: &CalcValue)
fn visit_calc_value(&mut self, n: &CalcValue)
§fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)
fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)
fn visit_calc_value_or_operators(&mut self, n: &[CalcValueOrOperator])
§fn visit_class_selector(&mut self, n: &ClassSelector)
fn visit_class_selector(&mut self, n: &ClassSelector)
§fn visit_cmyk_component(&mut self, n: &CmykComponent)
fn visit_cmyk_component(&mut self, n: &CmykComponent)
§fn visit_color(&mut self, n: &Color)
fn visit_color(&mut self, n: &Color)
§fn visit_color_profile_name(&mut self, n: &ColorProfileName)
fn visit_color_profile_name(&mut self, n: &ColorProfileName)
§fn visit_combinator(&mut self, n: &Combinator)
fn visit_combinator(&mut self, n: &Combinator)
fn visit_combinator_value(&mut self, n: &CombinatorValue)
§fn visit_complex_selector(&mut self, n: &ComplexSelector)
fn visit_complex_selector(&mut self, n: &ComplexSelector)
§fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)
fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)
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)
fn visit_component_value(&mut self, n: &ComponentValue)
fn visit_component_values(&mut self, n: &[ComponentValue])
§fn visit_compound_selector(&mut self, n: &CompoundSelector)
fn visit_compound_selector(&mut self, n: &CompoundSelector)
§fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)
fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)
fn visit_compound_selectors(&mut self, n: &[CompoundSelector])
§fn visit_container_condition(&mut self, n: &ContainerCondition)
fn visit_container_condition(&mut self, n: &ContainerCondition)
§fn visit_container_name(&mut self, n: &ContainerName)
fn visit_container_name(&mut self, n: &ContainerName)
§fn visit_container_query(&mut self, n: &ContainerQuery)
fn visit_container_query(&mut self, n: &ContainerQuery)
§fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)
fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)
§fn visit_container_query_not(&mut self, n: &ContainerQueryNot)
fn visit_container_query_not(&mut self, n: &ContainerQueryNot)
§fn visit_container_query_or(&mut self, n: &ContainerQueryOr)
fn visit_container_query_or(&mut self, n: &ContainerQueryOr)
§fn visit_container_query_type(&mut self, n: &ContainerQueryType)
fn visit_container_query_type(&mut self, n: &ContainerQueryType)
fn visit_container_query_types(&mut self, n: &[ContainerQueryType])
§fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)
fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)
§fn visit_custom_ident(&mut self, n: &CustomIdent)
fn visit_custom_ident(&mut self, n: &CustomIdent)
fn visit_custom_idents(&mut self, n: &[CustomIdent])
§fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)
fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)
§fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)
fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)
§fn visit_custom_property_name(&mut self, n: &CustomPropertyName)
fn visit_custom_property_name(&mut self, n: &CustomPropertyName)
§fn visit_dashed_ident(&mut self, n: &DashedIdent)
fn visit_dashed_ident(&mut self, n: &DashedIdent)
§fn visit_declaration(&mut self, n: &Declaration)
fn visit_declaration(&mut self, n: &Declaration)
§fn visit_declaration_name(&mut self, n: &DeclarationName)
fn visit_declaration_name(&mut self, n: &DeclarationName)
§fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)
fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)
§fn visit_delimiter(&mut self, n: &Delimiter)
fn visit_delimiter(&mut self, n: &Delimiter)
§fn visit_delimiter_value(&mut self, n: &DelimiterValue)
fn visit_delimiter_value(&mut self, n: &DelimiterValue)
§fn visit_dimension(&mut self, n: &Dimension)
fn visit_dimension(&mut self, n: &Dimension)
§fn visit_document_prelude(&mut self, n: &DocumentPrelude)
fn visit_document_prelude(&mut self, n: &DocumentPrelude)
§fn visit_document_prelude_matching_function(
&mut self,
n: &DocumentPreludeMatchingFunction
)
fn visit_document_prelude_matching_function( &mut self, n: &DocumentPreludeMatchingFunction )
fn visit_document_prelude_matching_functions( &mut self, n: &[DocumentPreludeMatchingFunction] )
§fn visit_extension_name(&mut self, n: &ExtensionName)
fn visit_extension_name(&mut self, n: &ExtensionName)
§fn visit_family_name(&mut self, n: &FamilyName)
fn visit_family_name(&mut self, n: &FamilyName)
fn visit_family_names(&mut self, n: &[FamilyName])
§fn visit_flex(&mut self, n: &Flex)
fn visit_flex(&mut self, n: &Flex)
§fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)
fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)
§fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)
fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)
fn visit_forgiving_complex_selectors(&mut self, n: &[ForgivingComplexSelector])
§fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)
fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)
§fn visit_forgiving_relative_selector_list(
&mut self,
n: &ForgivingRelativeSelectorList
)
fn visit_forgiving_relative_selector_list( &mut self, n: &ForgivingRelativeSelectorList )
fn visit_forgiving_relative_selectors( &mut self, n: &[ForgivingRelativeSelector] )
§fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)
fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)
§fn visit_frequency(&mut self, n: &Frequency)
fn visit_frequency(&mut self, n: &Frequency)
§fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)
fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)
§fn visit_function(&mut self, n: &Function)
fn visit_function(&mut self, n: &Function)
§fn visit_function_name(&mut self, n: &FunctionName)
fn visit_function_name(&mut self, n: &FunctionName)
§fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)
fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)
§fn visit_hex_color(&mut self, n: &HexColor)
fn visit_hex_color(&mut self, n: &HexColor)
§fn visit_hue(&mut self, n: &Hue)
fn visit_hue(&mut self, n: &Hue)
fn visit_i_32(&mut self, n: &i32)
§fn visit_id_selector(&mut self, n: &IdSelector)
fn visit_id_selector(&mut self, n: &IdSelector)
§fn visit_ident(&mut self, n: &Ident)
fn visit_ident(&mut self, n: &Ident)
fn visit_idents(&mut self, n: &[Ident])
§fn visit_import_conditions(&mut self, n: &ImportConditions)
fn visit_import_conditions(&mut self, n: &ImportConditions)
§fn visit_import_href(&mut self, n: &ImportHref)
fn visit_import_href(&mut self, n: &ImportHref)
§fn visit_import_layer_name(&mut self, n: &ImportLayerName)
fn visit_import_layer_name(&mut self, n: &ImportLayerName)
§fn visit_import_prelude(&mut self, n: &ImportPrelude)
fn visit_import_prelude(&mut self, n: &ImportPrelude)
§fn visit_important_flag(&mut self, n: &ImportantFlag)
fn visit_important_flag(&mut self, n: &ImportantFlag)
§fn visit_integer(&mut self, n: &Integer)
fn visit_integer(&mut self, n: &Integer)
§fn visit_keyframe_block(&mut self, n: &KeyframeBlock)
fn visit_keyframe_block(&mut self, n: &KeyframeBlock)
§fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)
fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)
fn visit_keyframe_selectors(&mut self, n: &[KeyframeSelector])
§fn visit_keyframes_name(&mut self, n: &KeyframesName)
fn visit_keyframes_name(&mut self, n: &KeyframesName)
§fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)
fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)
§fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)
fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)
§fn visit_layer_name(&mut self, n: &LayerName)
fn visit_layer_name(&mut self, n: &LayerName)
§fn visit_layer_name_list(&mut self, n: &LayerNameList)
fn visit_layer_name_list(&mut self, n: &LayerNameList)
fn visit_layer_names(&mut self, n: &[LayerName])
§fn visit_layer_prelude(&mut self, n: &LayerPrelude)
fn visit_layer_prelude(&mut self, n: &LayerPrelude)
§fn visit_length(&mut self, n: &Length)
fn visit_length(&mut self, n: &Length)
§fn visit_length_percentage(&mut self, n: &LengthPercentage)
fn visit_length_percentage(&mut self, n: &LengthPercentage)
§fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)
fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)
§fn visit_media_and(&mut self, n: &MediaAnd)
fn visit_media_and(&mut self, n: &MediaAnd)
§fn visit_media_condition(&mut self, n: &MediaCondition)
fn visit_media_condition(&mut self, n: &MediaCondition)
§fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)
fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)
fn visit_media_condition_all_types(&mut self, n: &[MediaConditionAllType])
§fn visit_media_condition_type(&mut self, n: &MediaConditionType)
fn visit_media_condition_type(&mut self, n: &MediaConditionType)
§fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)
fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)
§fn visit_media_condition_without_or_type(
&mut self,
n: &MediaConditionWithoutOrType
)
fn visit_media_condition_without_or_type( &mut self, n: &MediaConditionWithoutOrType )
fn visit_media_condition_without_or_types( &mut self, n: &[MediaConditionWithoutOrType] )
§fn visit_media_feature(&mut self, n: &MediaFeature)
fn visit_media_feature(&mut self, n: &MediaFeature)
§fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)
fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)
§fn visit_media_feature_name(&mut self, n: &MediaFeatureName)
fn visit_media_feature_name(&mut self, n: &MediaFeatureName)
§fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)
fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)
§fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)
fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)
fn visit_media_feature_range_comparison( &mut self, n: &MediaFeatureRangeComparison )
§fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)
fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)
§fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)
fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)
§fn visit_media_in_parens(&mut self, n: &MediaInParens)
fn visit_media_in_parens(&mut self, n: &MediaInParens)
§fn visit_media_not(&mut self, n: &MediaNot)
fn visit_media_not(&mut self, n: &MediaNot)
§fn visit_media_or(&mut self, n: &MediaOr)
fn visit_media_or(&mut self, n: &MediaOr)
fn visit_media_queries(&mut self, n: &[MediaQuery])
§fn visit_media_query(&mut self, n: &MediaQuery)
fn visit_media_query(&mut self, n: &MediaQuery)
§fn visit_media_query_list(&mut self, n: &MediaQueryList)
fn visit_media_query_list(&mut self, n: &MediaQueryList)
§fn visit_media_type(&mut self, n: &MediaType)
fn visit_media_type(&mut self, n: &MediaType)
§fn visit_named_namespace(&mut self, n: &NamedNamespace)
fn visit_named_namespace(&mut self, n: &NamedNamespace)
§fn visit_namespace(&mut self, n: &Namespace)
fn visit_namespace(&mut self, n: &Namespace)
§fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)
fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)
§fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)
fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)
§fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)
fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)
§fn visit_nesting_selector(&mut self, n: &NestingSelector)
fn visit_nesting_selector(&mut self, n: &NestingSelector)
§fn visit_number(&mut self, n: &Number)
fn visit_number(&mut self, n: &Number)
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)
fn visit_page_selector(&mut self, n: &PageSelector)
§fn visit_page_selector_list(&mut self, n: &PageSelectorList)
fn visit_page_selector_list(&mut self, n: &PageSelectorList)
§fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)
fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)
fn visit_page_selector_pseudos(&mut self, n: &[PageSelectorPseudo])
§fn visit_page_selector_type(&mut self, n: &PageSelectorType)
fn visit_page_selector_type(&mut self, n: &PageSelectorType)
fn visit_page_selectors(&mut self, n: &[PageSelector])
§fn visit_percentage(&mut self, n: &Percentage)
fn visit_percentage(&mut self, n: &Percentage)
§fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)
fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)
§fn visit_pseudo_class_selector_children(
&mut self,
n: &PseudoClassSelectorChildren
)
fn visit_pseudo_class_selector_children( &mut self, n: &PseudoClassSelectorChildren )
fn visit_pseudo_class_selector_children_vec( &mut self, n: &[PseudoClassSelectorChildren] )
§fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)
fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)
§fn visit_pseudo_element_selector_children(
&mut self,
n: &PseudoElementSelectorChildren
)
fn visit_pseudo_element_selector_children( &mut self, n: &PseudoElementSelectorChildren )
fn visit_pseudo_element_selector_children_vec( &mut self, n: &[PseudoElementSelectorChildren] )
§fn visit_qualified_rule(&mut self, n: &QualifiedRule)
fn visit_qualified_rule(&mut self, n: &QualifiedRule)
§fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)
fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)
§fn visit_query_in_parens(&mut self, n: &QueryInParens)
fn visit_query_in_parens(&mut self, n: &QueryInParens)
§fn visit_ratio(&mut self, n: &Ratio)
fn visit_ratio(&mut self, n: &Ratio)
§fn visit_relative_selector(&mut self, n: &RelativeSelector)
fn visit_relative_selector(&mut self, n: &RelativeSelector)
§fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)
fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)
fn visit_relative_selectors(&mut self, n: &[RelativeSelector])
§fn visit_resolution(&mut self, n: &Resolution)
fn visit_resolution(&mut self, n: &Resolution)
§fn visit_rule(&mut self, n: &Rule)
fn visit_rule(&mut self, n: &Rule)
fn visit_rules(&mut self, n: &[Rule])
§fn visit_scope_range(&mut self, n: &ScopeRange)
fn visit_scope_range(&mut self, n: &ScopeRange)
§fn visit_selector_list(&mut self, n: &SelectorList)
fn visit_selector_list(&mut self, n: &SelectorList)
§fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)
fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)
§fn visit_simple_block(&mut self, n: &SimpleBlock)
fn visit_simple_block(&mut self, n: &SimpleBlock)
§fn visit_size_feature(&mut self, n: &SizeFeature)
fn visit_size_feature(&mut self, n: &SizeFeature)
§fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)
fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)
§fn visit_size_feature_name(&mut self, n: &SizeFeatureName)
fn visit_size_feature_name(&mut self, n: &SizeFeatureName)
§fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)
fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)
§fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)
fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)
§fn visit_size_feature_range_comparison(
&mut self,
n: &SizeFeatureRangeComparison
)
fn visit_size_feature_range_comparison( &mut self, n: &SizeFeatureRangeComparison )
§fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)
fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)
§fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)
fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)
fn visit_span(&mut self, n: &Span)
§fn visit_str(&mut self, n: &Str)
fn visit_str(&mut self, n: &Str)
§fn visit_style_block(&mut self, n: &StyleBlock)
fn visit_style_block(&mut self, n: &StyleBlock)
§fn visit_stylesheet(&mut self, n: &Stylesheet)
fn visit_stylesheet(&mut self, n: &Stylesheet)
§fn visit_subclass_selector(&mut self, n: &SubclassSelector)
fn visit_subclass_selector(&mut self, n: &SubclassSelector)
fn visit_subclass_selectors(&mut self, n: &[SubclassSelector])
§fn visit_supports_and(&mut self, n: &SupportsAnd)
fn visit_supports_and(&mut self, n: &SupportsAnd)
§fn visit_supports_condition(&mut self, n: &SupportsCondition)
fn visit_supports_condition(&mut self, n: &SupportsCondition)
§fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)
fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)
fn visit_supports_condition_types(&mut self, n: &[SupportsConditionType])
§fn visit_supports_feature(&mut self, n: &SupportsFeature)
fn visit_supports_feature(&mut self, n: &SupportsFeature)
§fn visit_supports_in_parens(&mut self, n: &SupportsInParens)
fn visit_supports_in_parens(&mut self, n: &SupportsInParens)
§fn visit_supports_not(&mut self, n: &SupportsNot)
fn visit_supports_not(&mut self, n: &SupportsNot)
§fn visit_supports_or(&mut self, n: &SupportsOr)
fn visit_supports_or(&mut self, n: &SupportsOr)
§fn visit_tag_name_selector(&mut self, n: &TagNameSelector)
fn visit_tag_name_selector(&mut self, n: &TagNameSelector)
§fn visit_time(&mut self, n: &Time)
fn visit_time(&mut self, n: &Time)
§fn visit_time_percentage(&mut self, n: &TimePercentage)
fn visit_time_percentage(&mut self, n: &TimePercentage)
fn visit_token(&mut self, n: &Token)
§fn visit_token_and_span(&mut self, n: &TokenAndSpan)
fn visit_token_and_span(&mut self, n: &TokenAndSpan)
§fn visit_type_selector(&mut self, n: &TypeSelector)
fn visit_type_selector(&mut self, n: &TypeSelector)
§fn visit_unicode_range(&mut self, n: &UnicodeRange)
fn visit_unicode_range(&mut self, n: &UnicodeRange)
§fn visit_universal_selector(&mut self, n: &UniversalSelector)
fn visit_universal_selector(&mut self, n: &UniversalSelector)
§fn visit_unknown_dimension(&mut self, n: &UnknownDimension)
fn visit_unknown_dimension(&mut self, n: &UnknownDimension)
§fn visit_url(&mut self, n: &Url)
fn visit_url(&mut self, n: &Url)
§fn visit_url_modifier(&mut self, n: &UrlModifier)
fn visit_url_modifier(&mut self, n: &UrlModifier)
fn visit_url_modifiers(&mut self, n: &[UrlModifier])
§fn visit_url_value(&mut self, n: &UrlValue)
fn visit_url_value(&mut self, n: &UrlValue)
§fn visit_url_value_raw(&mut self, n: &UrlValueRaw)
fn visit_url_value_raw(&mut self, n: &UrlValueRaw)
§fn visit_wq_name(&mut self, n: &WqName)
fn visit_wq_name(&mut self, n: &WqName)
§impl<A, B> VisitAll for Either<A, B>
impl<A, B> VisitAll for Either<A, B>
§fn visit_accessibility(&mut self, n: &Accessibility)
fn visit_accessibility(&mut self, n: &Accessibility)
§fn visit_array_lit(&mut self, n: &ArrayLit)
fn visit_array_lit(&mut self, n: &ArrayLit)
§fn visit_array_pat(&mut self, n: &ArrayPat)
fn visit_array_pat(&mut self, n: &ArrayPat)
§fn visit_arrow_expr(&mut self, n: &ArrowExpr)
fn visit_arrow_expr(&mut self, n: &ArrowExpr)
§fn visit_assign_expr(&mut self, n: &AssignExpr)
fn visit_assign_expr(&mut self, n: &AssignExpr)
§fn visit_assign_op(&mut self, n: &AssignOp)
fn visit_assign_op(&mut self, n: &AssignOp)
§fn visit_assign_pat(&mut self, n: &AssignPat)
fn visit_assign_pat(&mut self, n: &AssignPat)
§fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
fn visit_assign_pat_prop(&mut self, n: &AssignPatProp)
§fn visit_assign_prop(&mut self, n: &AssignProp)
fn visit_assign_prop(&mut self, n: &AssignProp)
§fn visit_assign_target(&mut self, n: &AssignTarget)
fn visit_assign_target(&mut self, n: &AssignTarget)
§fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)
fn visit_assign_target_pat(&mut self, n: &AssignTargetPat)
fn visit_atom(&mut self, n: &Atom)
§fn visit_auto_accessor(&mut self, n: &AutoAccessor)
fn visit_auto_accessor(&mut self, n: &AutoAccessor)
§fn visit_await_expr(&mut self, n: &AwaitExpr)
fn visit_await_expr(&mut self, n: &AwaitExpr)
§fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int(&mut self, n: &BigInt)
fn visit_big_int_value(&mut self, n: &BigInt)
§fn visit_bin_expr(&mut self, n: &BinExpr)
fn visit_bin_expr(&mut self, n: &BinExpr)
§fn visit_binary_op(&mut self, n: &BinaryOp)
fn visit_binary_op(&mut self, n: &BinaryOp)
§fn visit_binding_ident(&mut self, n: &BindingIdent)
fn visit_binding_ident(&mut self, n: &BindingIdent)
§fn visit_block_stmt(&mut self, n: &BlockStmt)
fn visit_block_stmt(&mut self, n: &BlockStmt)
§fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr)
§fn visit_bool(&mut self, n: &Bool)
fn visit_bool(&mut self, n: &Bool)
§fn visit_break_stmt(&mut self, n: &BreakStmt)
fn visit_break_stmt(&mut self, n: &BreakStmt)
§fn visit_call_expr(&mut self, n: &CallExpr)
fn visit_call_expr(&mut self, n: &CallExpr)
§fn visit_callee(&mut self, n: &Callee)
fn visit_callee(&mut self, n: &Callee)
§fn visit_catch_clause(&mut self, n: &CatchClause)
fn visit_catch_clause(&mut self, n: &CatchClause)
§fn visit_class(&mut self, n: &Class)
fn visit_class(&mut self, n: &Class)
§fn visit_class_decl(&mut self, n: &ClassDecl)
fn visit_class_decl(&mut self, n: &ClassDecl)
§fn visit_class_expr(&mut self, n: &ClassExpr)
fn visit_class_expr(&mut self, n: &ClassExpr)
§fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_member(&mut self, n: &ClassMember)
fn visit_class_members(&mut self, n: &[ClassMember])
§fn visit_class_method(&mut self, n: &ClassMethod)
fn visit_class_method(&mut self, n: &ClassMethod)
§fn visit_class_prop(&mut self, n: &ClassProp)
fn visit_class_prop(&mut self, n: &ClassProp)
§fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
fn visit_computed_prop_name(&mut self, n: &ComputedPropName)
§fn visit_cond_expr(&mut self, n: &CondExpr)
fn visit_cond_expr(&mut self, n: &CondExpr)
§fn visit_constructor(&mut self, n: &Constructor)
fn visit_constructor(&mut self, n: &Constructor)
§fn visit_continue_stmt(&mut self, n: &ContinueStmt)
fn visit_continue_stmt(&mut self, n: &ContinueStmt)
§fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
fn visit_debugger_stmt(&mut self, n: &DebuggerStmt)
§fn visit_decl(&mut self, n: &Decl)
fn visit_decl(&mut self, n: &Decl)
§fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorator(&mut self, n: &Decorator)
fn visit_decorators(&mut self, n: &[Decorator])
§fn visit_default_decl(&mut self, n: &DefaultDecl)
fn visit_default_decl(&mut self, n: &DefaultDecl)
§fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
fn visit_do_while_stmt(&mut self, n: &DoWhileStmt)
§fn visit_empty_stmt(&mut self, n: &EmptyStmt)
fn visit_empty_stmt(&mut self, n: &EmptyStmt)
§fn visit_export_all(&mut self, n: &ExportAll)
fn visit_export_all(&mut self, n: &ExportAll)
§fn visit_export_decl(&mut self, n: &ExportDecl)
fn visit_export_decl(&mut self, n: &ExportDecl)
§fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
fn visit_export_default_decl(&mut self, n: &ExportDefaultDecl)
§fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
fn visit_export_default_expr(&mut self, n: &ExportDefaultExpr)
§fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
fn visit_export_default_specifier(&mut self, n: &ExportDefaultSpecifier)
§fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
fn visit_export_named_specifier(&mut self, n: &ExportNamedSpecifier)
§fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
fn visit_export_namespace_specifier(&mut self, n: &ExportNamespaceSpecifier)
§fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifier(&mut self, n: &ExportSpecifier)
fn visit_export_specifiers(&mut self, n: &[ExportSpecifier])
§fn visit_expr(&mut self, n: &Expr)
fn visit_expr(&mut self, n: &Expr)
§fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spread(&mut self, n: &ExprOrSpread)
fn visit_expr_or_spreads(&mut self, n: &[ExprOrSpread])
§fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_expr_stmt(&mut self, n: &ExprStmt)
fn visit_exprs(&mut self, n: &[Box<Expr>])
§fn visit_fn_decl(&mut self, n: &FnDecl)
fn visit_fn_decl(&mut self, n: &FnDecl)
§fn visit_fn_expr(&mut self, n: &FnExpr)
fn visit_fn_expr(&mut self, n: &FnExpr)
§fn visit_for_head(&mut self, n: &ForHead)
fn visit_for_head(&mut self, n: &ForHead)
§fn visit_for_in_stmt(&mut self, n: &ForInStmt)
fn visit_for_in_stmt(&mut self, n: &ForInStmt)
§fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
fn visit_for_of_stmt(&mut self, n: &ForOfStmt)
§fn visit_for_stmt(&mut self, n: &ForStmt)
fn visit_for_stmt(&mut self, n: &ForStmt)
§fn visit_function(&mut self, n: &Function)
fn visit_function(&mut self, n: &Function)
§fn visit_getter_prop(&mut self, n: &GetterProp)
fn visit_getter_prop(&mut self, n: &GetterProp)
§fn visit_ident(&mut self, n: &Ident)
fn visit_ident(&mut self, n: &Ident)
§fn visit_if_stmt(&mut self, n: &IfStmt)
fn visit_if_stmt(&mut self, n: &IfStmt)
§fn visit_import(&mut self, n: &Import)
fn visit_import(&mut self, n: &Import)
§fn visit_import_decl(&mut self, n: &ImportDecl)
fn visit_import_decl(&mut self, n: &ImportDecl)
§fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
fn visit_import_default_specifier(&mut self, n: &ImportDefaultSpecifier)
§fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_named_specifier(&mut self, n: &ImportNamedSpecifier)
fn visit_import_phase(&mut self, n: &ImportPhase)
§fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifier(&mut self, n: &ImportSpecifier)
fn visit_import_specifiers(&mut self, n: &[ImportSpecifier])
§fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
fn visit_import_star_as_specifier(&mut self, n: &ImportStarAsSpecifier)
§fn visit_invalid(&mut self, n: &Invalid)
fn visit_invalid(&mut self, n: &Invalid)
§fn visit_jsx_attr(&mut self, n: &JSXAttr)
fn visit_jsx_attr(&mut self, n: &JSXAttr)
§fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
fn visit_jsx_attr_name(&mut self, n: &JSXAttrName)
§fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spread(&mut self, n: &JSXAttrOrSpread)
fn visit_jsx_attr_or_spreads(&mut self, n: &[JSXAttrOrSpread])
§fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
fn visit_jsx_attr_value(&mut self, n: &JSXAttrValue)
§fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
fn visit_jsx_closing_element(&mut self, n: &JSXClosingElement)
§fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
fn visit_jsx_closing_fragment(&mut self, n: &JSXClosingFragment)
§fn visit_jsx_element(&mut self, n: &JSXElement)
fn visit_jsx_element(&mut self, n: &JSXElement)
§fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_child(&mut self, n: &JSXElementChild)
fn visit_jsx_element_children(&mut self, n: &[JSXElementChild])
§fn visit_jsx_element_name(&mut self, n: &JSXElementName)
fn visit_jsx_element_name(&mut self, n: &JSXElementName)
§fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
fn visit_jsx_empty_expr(&mut self, n: &JSXEmptyExpr)
§fn visit_jsx_expr(&mut self, n: &JSXExpr)
fn visit_jsx_expr(&mut self, n: &JSXExpr)
§fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
fn visit_jsx_expr_container(&mut self, n: &JSXExprContainer)
§fn visit_jsx_fragment(&mut self, n: &JSXFragment)
fn visit_jsx_fragment(&mut self, n: &JSXFragment)
§fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
fn visit_jsx_member_expr(&mut self, n: &JSXMemberExpr)
§fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
fn visit_jsx_namespaced_name(&mut self, n: &JSXNamespacedName)
§fn visit_jsx_object(&mut self, n: &JSXObject)
fn visit_jsx_object(&mut self, n: &JSXObject)
§fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement)
§fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
fn visit_jsx_opening_fragment(&mut self, n: &JSXOpeningFragment)
§fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
fn visit_jsx_spread_child(&mut self, n: &JSXSpreadChild)
§fn visit_jsx_text(&mut self, n: &JSXText)
fn visit_jsx_text(&mut self, n: &JSXText)
§fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
fn visit_key_value_pat_prop(&mut self, n: &KeyValuePatProp)
§fn visit_key_value_prop(&mut self, n: &KeyValueProp)
fn visit_key_value_prop(&mut self, n: &KeyValueProp)
§fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
fn visit_labeled_stmt(&mut self, n: &LabeledStmt)
§fn visit_member_expr(&mut self, n: &MemberExpr)
fn visit_member_expr(&mut self, n: &MemberExpr)
§fn visit_member_prop(&mut self, n: &MemberProp)
fn visit_member_prop(&mut self, n: &MemberProp)
§fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr)
§fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
fn visit_meta_prop_kind(&mut self, n: &MetaPropKind)
§fn visit_method_kind(&mut self, n: &MethodKind)
fn visit_method_kind(&mut self, n: &MethodKind)
§fn visit_method_prop(&mut self, n: &MethodProp)
fn visit_method_prop(&mut self, n: &MethodProp)
§fn visit_module(&mut self, n: &Module)
fn visit_module(&mut self, n: &Module)
§fn visit_module_decl(&mut self, n: &ModuleDecl)
fn visit_module_decl(&mut self, n: &ModuleDecl)
§fn visit_module_export_name(&mut self, n: &ModuleExportName)
fn visit_module_export_name(&mut self, n: &ModuleExportName)
§fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_item(&mut self, n: &ModuleItem)
fn visit_module_items(&mut self, n: &[ModuleItem])
§fn visit_named_export(&mut self, n: &NamedExport)
fn visit_named_export(&mut self, n: &NamedExport)
§fn visit_new_expr(&mut self, n: &NewExpr)
fn visit_new_expr(&mut self, n: &NewExpr)
§fn visit_null(&mut self, n: &Null)
fn visit_null(&mut self, n: &Null)
§fn visit_number(&mut self, n: &Number)
fn visit_number(&mut self, n: &Number)
§fn visit_object_lit(&mut self, n: &ObjectLit)
fn visit_object_lit(&mut self, n: &ObjectLit)
§fn visit_object_pat(&mut self, n: &ObjectPat)
fn visit_object_pat(&mut self, n: &ObjectPat)
§fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_prop(&mut self, n: &ObjectPatProp)
fn visit_object_pat_props(&mut self, n: &[ObjectPatProp])
fn visit_opt_accessibility(&mut self, n: Option<&Accessibility>)
fn visit_opt_atom(&mut self, n: Option<&Atom>)
fn visit_opt_block_stmt(&mut self, n: Option<&BlockStmt>)
§fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_call(&mut self, n: &OptCall)
fn visit_opt_catch_clause(&mut self, n: Option<&CatchClause>)
§fn visit_opt_chain_base(&mut self, n: &OptChainBase)
fn visit_opt_chain_base(&mut self, n: &OptChainBase)
§fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
fn visit_opt_chain_expr(&mut self, n: &OptChainExpr)
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)
fn visit_param(&mut self, n: &Param)
§fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_prop(&mut self, n: &ParamOrTsParamProp)
fn visit_param_or_ts_param_props(&mut self, n: &[ParamOrTsParamProp])
fn visit_params(&mut self, n: &[Param])
§fn visit_paren_expr(&mut self, n: &ParenExpr)
fn visit_paren_expr(&mut self, n: &ParenExpr)
fn visit_pats(&mut self, n: &[Pat])
§fn visit_private_method(&mut self, n: &PrivateMethod)
fn visit_private_method(&mut self, n: &PrivateMethod)
§fn visit_private_name(&mut self, n: &PrivateName)
fn visit_private_name(&mut self, n: &PrivateName)
§fn visit_private_prop(&mut self, n: &PrivateProp)
fn visit_private_prop(&mut self, n: &PrivateProp)
§fn visit_program(&mut self, n: &Program)
fn visit_program(&mut self, n: &Program)
§fn visit_prop(&mut self, n: &Prop)
fn visit_prop(&mut self, n: &Prop)
§fn visit_prop_name(&mut self, n: &PropName)
fn visit_prop_name(&mut self, n: &PropName)
§fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spread(&mut self, n: &PropOrSpread)
fn visit_prop_or_spreads(&mut self, n: &[PropOrSpread])
§fn visit_regex(&mut self, n: &Regex)
fn visit_regex(&mut self, n: &Regex)
§fn visit_reserved_unused(&mut self, n: &ReservedUnused)
fn visit_reserved_unused(&mut self, n: &ReservedUnused)
§fn visit_rest_pat(&mut self, n: &RestPat)
fn visit_rest_pat(&mut self, n: &RestPat)
§fn visit_return_stmt(&mut self, n: &ReturnStmt)
fn visit_return_stmt(&mut self, n: &ReturnStmt)
§fn visit_script(&mut self, n: &Script)
fn visit_script(&mut self, n: &Script)
§fn visit_seq_expr(&mut self, n: &SeqExpr)
fn visit_seq_expr(&mut self, n: &SeqExpr)
§fn visit_setter_prop(&mut self, n: &SetterProp)
fn visit_setter_prop(&mut self, n: &SetterProp)
§fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)
fn visit_simple_assign_target(&mut self, n: &SimpleAssignTarget)
fn visit_span(&mut self, n: &Span)
§fn visit_spread_element(&mut self, n: &SpreadElement)
fn visit_spread_element(&mut self, n: &SpreadElement)
§fn visit_static_block(&mut self, n: &StaticBlock)
fn visit_static_block(&mut self, n: &StaticBlock)
§fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmt(&mut self, n: &Stmt)
fn visit_stmts(&mut self, n: &[Stmt])
§fn visit_super(&mut self, n: &Super)
fn visit_super(&mut self, n: &Super)
§fn visit_super_prop(&mut self, n: &SuperProp)
fn visit_super_prop(&mut self, n: &SuperProp)
§fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
fn visit_super_prop_expr(&mut self, n: &SuperPropExpr)
§fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_case(&mut self, n: &SwitchCase)
fn visit_switch_cases(&mut self, n: &[SwitchCase])
§fn visit_switch_stmt(&mut self, n: &SwitchStmt)
fn visit_switch_stmt(&mut self, n: &SwitchStmt)
§fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
fn visit_tagged_tpl(&mut self, n: &TaggedTpl)
§fn visit_this_expr(&mut self, n: &ThisExpr)
fn visit_this_expr(&mut self, n: &ThisExpr)
§fn visit_throw_stmt(&mut self, n: &ThrowStmt)
fn visit_throw_stmt(&mut self, n: &ThrowStmt)
§fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_element(&mut self, n: &TplElement)
fn visit_tpl_elements(&mut self, n: &[TplElement])
§fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
fn visit_true_plus_minus(&mut self, n: &TruePlusMinus)
§fn visit_try_stmt(&mut self, n: &TryStmt)
fn visit_try_stmt(&mut self, n: &TryStmt)
§fn visit_ts_array_type(&mut self, n: &TsArrayType)
fn visit_ts_array_type(&mut self, n: &TsArrayType)
§fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
fn visit_ts_as_expr(&mut self, n: &TsAsExpr)
§fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
fn visit_ts_call_signature_decl(&mut self, n: &TsCallSignatureDecl)
§fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
fn visit_ts_conditional_type(&mut self, n: &TsConditionalType)
§fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
fn visit_ts_const_assertion(&mut self, n: &TsConstAssertion)
§fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
fn visit_ts_construct_signature_decl(&mut self, n: &TsConstructSignatureDecl)
§fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
fn visit_ts_constructor_type(&mut self, n: &TsConstructorType)
§fn visit_ts_entity_name(&mut self, n: &TsEntityName)
fn visit_ts_entity_name(&mut self, n: &TsEntityName)
§fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
fn visit_ts_enum_decl(&mut self, n: &TsEnumDecl)
§fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
fn visit_ts_enum_member(&mut self, n: &TsEnumMember)
§fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_member_id(&mut self, n: &TsEnumMemberId)
fn visit_ts_enum_members(&mut self, n: &[TsEnumMember])
§fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
fn visit_ts_export_assignment(&mut self, n: &TsExportAssignment)
§fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args(&mut self, n: &TsExprWithTypeArgs)
fn visit_ts_expr_with_type_args_vec(&mut self, n: &[TsExprWithTypeArgs])
§fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
fn visit_ts_external_module_ref(&mut self, n: &TsExternalModuleRef)
§fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
fn visit_ts_fn_or_constructor_type(&mut self, n: &TsFnOrConstructorType)
§fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_param(&mut self, n: &TsFnParam)
fn visit_ts_fn_params(&mut self, n: &[TsFnParam])
§fn visit_ts_fn_type(&mut self, n: &TsFnType)
fn visit_ts_fn_type(&mut self, n: &TsFnType)
§fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
fn visit_ts_getter_signature(&mut self, n: &TsGetterSignature)
§fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
fn visit_ts_import_equals_decl(&mut self, n: &TsImportEqualsDecl)
§fn visit_ts_import_type(&mut self, n: &TsImportType)
fn visit_ts_import_type(&mut self, n: &TsImportType)
§fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
fn visit_ts_index_signature(&mut self, n: &TsIndexSignature)
§fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
fn visit_ts_indexed_access_type(&mut self, n: &TsIndexedAccessType)
§fn visit_ts_infer_type(&mut self, n: &TsInferType)
fn visit_ts_infer_type(&mut self, n: &TsInferType)
§fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
fn visit_ts_instantiation(&mut self, n: &TsInstantiation)
§fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
fn visit_ts_interface_body(&mut self, n: &TsInterfaceBody)
§fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
fn visit_ts_interface_decl(&mut self, n: &TsInterfaceDecl)
§fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
fn visit_ts_intersection_type(&mut self, n: &TsIntersectionType)
§fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
fn visit_ts_keyword_type(&mut self, n: &TsKeywordType)
§fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
fn visit_ts_keyword_type_kind(&mut self, n: &TsKeywordTypeKind)
§fn visit_ts_lit(&mut self, n: &TsLit)
fn visit_ts_lit(&mut self, n: &TsLit)
§fn visit_ts_lit_type(&mut self, n: &TsLitType)
fn visit_ts_lit_type(&mut self, n: &TsLitType)
§fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
fn visit_ts_mapped_type(&mut self, n: &TsMappedType)
§fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
fn visit_ts_method_signature(&mut self, n: &TsMethodSignature)
§fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
fn visit_ts_module_block(&mut self, n: &TsModuleBlock)
§fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
fn visit_ts_module_decl(&mut self, n: &TsModuleDecl)
§fn visit_ts_module_name(&mut self, n: &TsModuleName)
fn visit_ts_module_name(&mut self, n: &TsModuleName)
§fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
fn visit_ts_module_ref(&mut self, n: &TsModuleRef)
§fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
fn visit_ts_namespace_body(&mut self, n: &TsNamespaceBody)
§fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl)
§fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
fn visit_ts_namespace_export_decl(&mut self, n: &TsNamespaceExportDecl)
§fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
fn visit_ts_non_null_expr(&mut self, n: &TsNonNullExpr)
§fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
fn visit_ts_optional_type(&mut self, n: &TsOptionalType)
§fn visit_ts_param_prop(&mut self, n: &TsParamProp)
fn visit_ts_param_prop(&mut self, n: &TsParamProp)
§fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam)
§fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
fn visit_ts_parenthesized_type(&mut self, n: &TsParenthesizedType)
§fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
fn visit_ts_property_signature(&mut self, n: &TsPropertySignature)
§fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
fn visit_ts_qualified_name(&mut self, n: &TsQualifiedName)
§fn visit_ts_rest_type(&mut self, n: &TsRestType)
fn visit_ts_rest_type(&mut self, n: &TsRestType)
§fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)
fn visit_ts_satisfies_expr(&mut self, n: &TsSatisfiesExpr)
§fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
fn visit_ts_setter_signature(&mut self, n: &TsSetterSignature)
§fn visit_ts_this_type(&mut self, n: &TsThisType)
fn visit_ts_this_type(&mut self, n: &TsThisType)
§fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
fn visit_ts_this_type_or_ident(&mut self, n: &TsThisTypeOrIdent)
§fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
fn visit_ts_tpl_lit_type(&mut self, n: &TsTplLitType)
§fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_element(&mut self, n: &TsTupleElement)
fn visit_ts_tuple_elements(&mut self, n: &[TsTupleElement])
§fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
fn visit_ts_tuple_type(&mut self, n: &TsTupleType)
§fn visit_ts_type(&mut self, n: &TsType)
fn visit_ts_type(&mut self, n: &TsType)
§fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
fn visit_ts_type_alias_decl(&mut self, n: &TsTypeAliasDecl)
§fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
fn visit_ts_type_ann(&mut self, n: &TsTypeAnn)
§fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
fn visit_ts_type_assertion(&mut self, n: &TsTypeAssertion)
§fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_element(&mut self, n: &TsTypeElement)
fn visit_ts_type_elements(&mut self, n: &[TsTypeElement])
§fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
fn visit_ts_type_lit(&mut self, n: &TsTypeLit)
§fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
fn visit_ts_type_operator(&mut self, n: &TsTypeOperator)
§fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
fn visit_ts_type_operator_op(&mut self, n: &TsTypeOperatorOp)
§fn visit_ts_type_param(&mut self, n: &TsTypeParam)
fn visit_ts_type_param(&mut self, n: &TsTypeParam)
§fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
fn visit_ts_type_param_decl(&mut self, n: &TsTypeParamDecl)
§fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_param_instantiation(&mut self, n: &TsTypeParamInstantiation)
fn visit_ts_type_params(&mut self, n: &[TsTypeParam])
§fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
fn visit_ts_type_predicate(&mut self, n: &TsTypePredicate)
§fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
fn visit_ts_type_query(&mut self, n: &TsTypeQuery)
§fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
fn visit_ts_type_query_expr(&mut self, n: &TsTypeQueryExpr)
§fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_type_ref(&mut self, n: &TsTypeRef)
fn visit_ts_types(&mut self, n: &[Box<TsType>])
§fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
fn visit_ts_union_or_intersection_type(&mut self, n: &TsUnionOrIntersectionType)
§fn visit_ts_union_type(&mut self, n: &TsUnionType)
fn visit_ts_union_type(&mut self, n: &TsUnionType)
§fn visit_unary_expr(&mut self, n: &UnaryExpr)
fn visit_unary_expr(&mut self, n: &UnaryExpr)
§fn visit_unary_op(&mut self, n: &UnaryOp)
fn visit_unary_op(&mut self, n: &UnaryOp)
§fn visit_update_expr(&mut self, n: &UpdateExpr)
fn visit_update_expr(&mut self, n: &UpdateExpr)
§fn visit_update_op(&mut self, n: &UpdateOp)
fn visit_update_op(&mut self, n: &UpdateOp)
§fn visit_using_decl(&mut self, n: &UsingDecl)
fn visit_using_decl(&mut self, n: &UsingDecl)
§fn visit_var_decl(&mut self, n: &VarDecl)
fn visit_var_decl(&mut self, n: &VarDecl)
§fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
fn visit_var_decl_kind(&mut self, n: &VarDeclKind)
§fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
fn visit_var_decl_or_expr(&mut self, n: &VarDeclOrExpr)
§fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarator(&mut self, n: &VarDeclarator)
fn visit_var_declarators(&mut self, n: &[VarDeclarator])
§fn visit_while_stmt(&mut self, n: &WhileStmt)
fn visit_while_stmt(&mut self, n: &WhileStmt)
§fn visit_with_stmt(&mut self, n: &WithStmt)
fn visit_with_stmt(&mut self, n: &WithStmt)
§fn visit_yield_expr(&mut self, n: &YieldExpr)
fn visit_yield_expr(&mut self, n: &YieldExpr)
§impl<A, B> VisitAll for Either<A, B>where
A: VisitAll,
B: VisitAll,
impl<A, B> VisitAll for Either<A, B>where
A: VisitAll,
B: VisitAll,
§fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)
fn visit_absolute_color_base(&mut self, n: &AbsoluteColorBase)
§fn visit_alpha_value(&mut self, n: &AlphaValue)
fn visit_alpha_value(&mut self, n: &AlphaValue)
§fn visit_an_plus_b(&mut self, n: &AnPlusB)
fn visit_an_plus_b(&mut self, n: &AnPlusB)
§fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)
fn visit_an_plus_b_notation(&mut self, n: &AnPlusBNotation)
§fn visit_angle(&mut self, n: &Angle)
fn visit_angle(&mut self, n: &Angle)
§fn visit_angle_percentage(&mut self, n: &AnglePercentage)
fn visit_angle_percentage(&mut self, n: &AnglePercentage)
§fn visit_any_namespace(&mut self, n: &AnyNamespace)
fn visit_any_namespace(&mut self, n: &AnyNamespace)
§fn visit_at_rule(&mut self, n: &AtRule)
fn visit_at_rule(&mut self, n: &AtRule)
§fn visit_at_rule_name(&mut self, n: &AtRuleName)
fn visit_at_rule_name(&mut self, n: &AtRuleName)
§fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)
fn visit_at_rule_prelude(&mut self, n: &AtRulePrelude)
fn visit_atom(&mut self, n: &Atom)
§fn visit_attribute_selector(&mut self, n: &AttributeSelector)
fn visit_attribute_selector(&mut self, n: &AttributeSelector)
§fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)
fn visit_attribute_selector_matcher(&mut self, n: &AttributeSelectorMatcher)
fn visit_attribute_selector_matcher_value( &mut self, n: &AttributeSelectorMatcherValue )
§fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)
fn visit_attribute_selector_modifier(&mut self, n: &AttributeSelectorModifier)
§fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)
fn visit_attribute_selector_value(&mut self, n: &AttributeSelectorValue)
§fn visit_calc_operator(&mut self, n: &CalcOperator)
fn visit_calc_operator(&mut self, n: &CalcOperator)
§fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)
fn visit_calc_operator_type(&mut self, n: &CalcOperatorType)
§fn visit_calc_product(&mut self, n: &CalcProduct)
fn visit_calc_product(&mut self, n: &CalcProduct)
§fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)
fn visit_calc_product_or_operator(&mut self, n: &CalcProductOrOperator)
fn visit_calc_product_or_operators(&mut self, n: &[CalcProductOrOperator])
§fn visit_calc_sum(&mut self, n: &CalcSum)
fn visit_calc_sum(&mut self, n: &CalcSum)
§fn visit_calc_value(&mut self, n: &CalcValue)
fn visit_calc_value(&mut self, n: &CalcValue)
§fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)
fn visit_calc_value_or_operator(&mut self, n: &CalcValueOrOperator)
fn visit_calc_value_or_operators(&mut self, n: &[CalcValueOrOperator])
§fn visit_class_selector(&mut self, n: &ClassSelector)
fn visit_class_selector(&mut self, n: &ClassSelector)
§fn visit_cmyk_component(&mut self, n: &CmykComponent)
fn visit_cmyk_component(&mut self, n: &CmykComponent)
§fn visit_color(&mut self, n: &Color)
fn visit_color(&mut self, n: &Color)
§fn visit_color_profile_name(&mut self, n: &ColorProfileName)
fn visit_color_profile_name(&mut self, n: &ColorProfileName)
§fn visit_combinator(&mut self, n: &Combinator)
fn visit_combinator(&mut self, n: &Combinator)
fn visit_combinator_value(&mut self, n: &CombinatorValue)
§fn visit_complex_selector(&mut self, n: &ComplexSelector)
fn visit_complex_selector(&mut self, n: &ComplexSelector)
§fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)
fn visit_complex_selector_children(&mut self, n: &ComplexSelectorChildren)
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)
fn visit_component_value(&mut self, n: &ComponentValue)
fn visit_component_values(&mut self, n: &[ComponentValue])
§fn visit_compound_selector(&mut self, n: &CompoundSelector)
fn visit_compound_selector(&mut self, n: &CompoundSelector)
§fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)
fn visit_compound_selector_list(&mut self, n: &CompoundSelectorList)
fn visit_compound_selectors(&mut self, n: &[CompoundSelector])
§fn visit_container_condition(&mut self, n: &ContainerCondition)
fn visit_container_condition(&mut self, n: &ContainerCondition)
§fn visit_container_name(&mut self, n: &ContainerName)
fn visit_container_name(&mut self, n: &ContainerName)
§fn visit_container_query(&mut self, n: &ContainerQuery)
fn visit_container_query(&mut self, n: &ContainerQuery)
§fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)
fn visit_container_query_and(&mut self, n: &ContainerQueryAnd)
§fn visit_container_query_not(&mut self, n: &ContainerQueryNot)
fn visit_container_query_not(&mut self, n: &ContainerQueryNot)
§fn visit_container_query_or(&mut self, n: &ContainerQueryOr)
fn visit_container_query_or(&mut self, n: &ContainerQueryOr)
§fn visit_container_query_type(&mut self, n: &ContainerQueryType)
fn visit_container_query_type(&mut self, n: &ContainerQueryType)
fn visit_container_query_types(&mut self, n: &[ContainerQueryType])
§fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)
fn visit_custom_highlight_name(&mut self, n: &CustomHighlightName)
§fn visit_custom_ident(&mut self, n: &CustomIdent)
fn visit_custom_ident(&mut self, n: &CustomIdent)
fn visit_custom_idents(&mut self, n: &[CustomIdent])
§fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)
fn visit_custom_media_query(&mut self, n: &CustomMediaQuery)
§fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)
fn visit_custom_media_query_media_type(&mut self, n: &CustomMediaQueryMediaType)
§fn visit_custom_property_name(&mut self, n: &CustomPropertyName)
fn visit_custom_property_name(&mut self, n: &CustomPropertyName)
§fn visit_dashed_ident(&mut self, n: &DashedIdent)
fn visit_dashed_ident(&mut self, n: &DashedIdent)
§fn visit_declaration(&mut self, n: &Declaration)
fn visit_declaration(&mut self, n: &Declaration)
§fn visit_declaration_name(&mut self, n: &DeclarationName)
fn visit_declaration_name(&mut self, n: &DeclarationName)
§fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)
fn visit_declaration_or_at_rule(&mut self, n: &DeclarationOrAtRule)
§fn visit_delimiter(&mut self, n: &Delimiter)
fn visit_delimiter(&mut self, n: &Delimiter)
§fn visit_delimiter_value(&mut self, n: &DelimiterValue)
fn visit_delimiter_value(&mut self, n: &DelimiterValue)
§fn visit_dimension(&mut self, n: &Dimension)
fn visit_dimension(&mut self, n: &Dimension)
§fn visit_document_prelude(&mut self, n: &DocumentPrelude)
fn visit_document_prelude(&mut self, n: &DocumentPrelude)
§fn visit_document_prelude_matching_function(
&mut self,
n: &DocumentPreludeMatchingFunction
)
fn visit_document_prelude_matching_function( &mut self, n: &DocumentPreludeMatchingFunction )
fn visit_document_prelude_matching_functions( &mut self, n: &[DocumentPreludeMatchingFunction] )
§fn visit_extension_name(&mut self, n: &ExtensionName)
fn visit_extension_name(&mut self, n: &ExtensionName)
§fn visit_family_name(&mut self, n: &FamilyName)
fn visit_family_name(&mut self, n: &FamilyName)
fn visit_family_names(&mut self, n: &[FamilyName])
§fn visit_flex(&mut self, n: &Flex)
fn visit_flex(&mut self, n: &Flex)
§fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)
fn visit_font_feature_values_prelude(&mut self, n: &FontFeatureValuesPrelude)
§fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)
fn visit_forgiving_complex_selector(&mut self, n: &ForgivingComplexSelector)
fn visit_forgiving_complex_selectors(&mut self, n: &[ForgivingComplexSelector])
§fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)
fn visit_forgiving_relative_selector(&mut self, n: &ForgivingRelativeSelector)
§fn visit_forgiving_relative_selector_list(
&mut self,
n: &ForgivingRelativeSelectorList
)
fn visit_forgiving_relative_selector_list( &mut self, n: &ForgivingRelativeSelectorList )
fn visit_forgiving_relative_selectors( &mut self, n: &[ForgivingRelativeSelector] )
§fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)
fn visit_forgiving_selector_list(&mut self, n: &ForgivingSelectorList)
§fn visit_frequency(&mut self, n: &Frequency)
fn visit_frequency(&mut self, n: &Frequency)
§fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)
fn visit_frequency_percentage(&mut self, n: &FrequencyPercentage)
§fn visit_function(&mut self, n: &Function)
fn visit_function(&mut self, n: &Function)
§fn visit_function_name(&mut self, n: &FunctionName)
fn visit_function_name(&mut self, n: &FunctionName)
§fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)
fn visit_general_enclosed(&mut self, n: &GeneralEnclosed)
§fn visit_hex_color(&mut self, n: &HexColor)
fn visit_hex_color(&mut self, n: &HexColor)
fn visit_i_32(&mut self, n: &i32)
§fn visit_id_selector(&mut self, n: &IdSelector)
fn visit_id_selector(&mut self, n: &IdSelector)
§fn visit_ident(&mut self, n: &Ident)
fn visit_ident(&mut self, n: &Ident)
fn visit_idents(&mut self, n: &[Ident])
§fn visit_import_conditions(&mut self, n: &ImportConditions)
fn visit_import_conditions(&mut self, n: &ImportConditions)
§fn visit_import_href(&mut self, n: &ImportHref)
fn visit_import_href(&mut self, n: &ImportHref)
§fn visit_import_layer_name(&mut self, n: &ImportLayerName)
fn visit_import_layer_name(&mut self, n: &ImportLayerName)
§fn visit_import_prelude(&mut self, n: &ImportPrelude)
fn visit_import_prelude(&mut self, n: &ImportPrelude)
§fn visit_important_flag(&mut self, n: &ImportantFlag)
fn visit_important_flag(&mut self, n: &ImportantFlag)
§fn visit_integer(&mut self, n: &Integer)
fn visit_integer(&mut self, n: &Integer)
§fn visit_keyframe_block(&mut self, n: &KeyframeBlock)
fn visit_keyframe_block(&mut self, n: &KeyframeBlock)
§fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)
fn visit_keyframe_selector(&mut self, n: &KeyframeSelector)
fn visit_keyframe_selectors(&mut self, n: &[KeyframeSelector])
§fn visit_keyframes_name(&mut self, n: &KeyframesName)
fn visit_keyframes_name(&mut self, n: &KeyframesName)
§fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)
fn visit_keyframes_pseudo_function(&mut self, n: &KeyframesPseudoFunction)
§fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)
fn visit_keyframes_pseudo_prefix(&mut self, n: &KeyframesPseudoPrefix)
§fn visit_layer_name(&mut self, n: &LayerName)
fn visit_layer_name(&mut self, n: &LayerName)
§fn visit_layer_name_list(&mut self, n: &LayerNameList)
fn visit_layer_name_list(&mut self, n: &LayerNameList)
fn visit_layer_names(&mut self, n: &[LayerName])
§fn visit_layer_prelude(&mut self, n: &LayerPrelude)
fn visit_layer_prelude(&mut self, n: &LayerPrelude)
§fn visit_length(&mut self, n: &Length)
fn visit_length(&mut self, n: &Length)
§fn visit_length_percentage(&mut self, n: &LengthPercentage)
fn visit_length_percentage(&mut self, n: &LengthPercentage)
§fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)
fn visit_list_of_component_values(&mut self, n: &ListOfComponentValues)
§fn visit_media_and(&mut self, n: &MediaAnd)
fn visit_media_and(&mut self, n: &MediaAnd)
§fn visit_media_condition(&mut self, n: &MediaCondition)
fn visit_media_condition(&mut self, n: &MediaCondition)
§fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)
fn visit_media_condition_all_type(&mut self, n: &MediaConditionAllType)
fn visit_media_condition_all_types(&mut self, n: &[MediaConditionAllType])
§fn visit_media_condition_type(&mut self, n: &MediaConditionType)
fn visit_media_condition_type(&mut self, n: &MediaConditionType)
§fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)
fn visit_media_condition_without_or(&mut self, n: &MediaConditionWithoutOr)
§fn visit_media_condition_without_or_type(
&mut self,
n: &MediaConditionWithoutOrType
)
fn visit_media_condition_without_or_type( &mut self, n: &MediaConditionWithoutOrType )
fn visit_media_condition_without_or_types( &mut self, n: &[MediaConditionWithoutOrType] )
§fn visit_media_feature(&mut self, n: &MediaFeature)
fn visit_media_feature(&mut self, n: &MediaFeature)
§fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)
fn visit_media_feature_boolean(&mut self, n: &MediaFeatureBoolean)
§fn visit_media_feature_name(&mut self, n: &MediaFeatureName)
fn visit_media_feature_name(&mut self, n: &MediaFeatureName)
§fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)
fn visit_media_feature_plain(&mut self, n: &MediaFeaturePlain)
§fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)
fn visit_media_feature_range(&mut self, n: &MediaFeatureRange)
fn visit_media_feature_range_comparison( &mut self, n: &MediaFeatureRangeComparison )
§fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)
fn visit_media_feature_range_interval(&mut self, n: &MediaFeatureRangeInterval)
§fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)
fn visit_media_feature_value(&mut self, n: &MediaFeatureValue)
§fn visit_media_in_parens(&mut self, n: &MediaInParens)
fn visit_media_in_parens(&mut self, n: &MediaInParens)
§fn visit_media_not(&mut self, n: &MediaNot)
fn visit_media_not(&mut self, n: &MediaNot)
§fn visit_media_or(&mut self, n: &MediaOr)
fn visit_media_or(&mut self, n: &MediaOr)
fn visit_media_queries(&mut self, n: &[MediaQuery])
§fn visit_media_query(&mut self, n: &MediaQuery)
fn visit_media_query(&mut self, n: &MediaQuery)
§fn visit_media_query_list(&mut self, n: &MediaQueryList)
fn visit_media_query_list(&mut self, n: &MediaQueryList)
§fn visit_media_type(&mut self, n: &MediaType)
fn visit_media_type(&mut self, n: &MediaType)
§fn visit_named_namespace(&mut self, n: &NamedNamespace)
fn visit_named_namespace(&mut self, n: &NamedNamespace)
§fn visit_namespace(&mut self, n: &Namespace)
fn visit_namespace(&mut self, n: &Namespace)
§fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)
fn visit_namespace_prefix(&mut self, n: &NamespacePrefix)
§fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)
fn visit_namespace_prelude(&mut self, n: &NamespacePrelude)
§fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)
fn visit_namespace_prelude_uri(&mut self, n: &NamespacePreludeUri)
§fn visit_nesting_selector(&mut self, n: &NestingSelector)
fn visit_nesting_selector(&mut self, n: &NestingSelector)
§fn visit_number(&mut self, n: &Number)
fn visit_number(&mut self, n: &Number)
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)
fn visit_page_selector(&mut self, n: &PageSelector)
§fn visit_page_selector_list(&mut self, n: &PageSelectorList)
fn visit_page_selector_list(&mut self, n: &PageSelectorList)
§fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)
fn visit_page_selector_pseudo(&mut self, n: &PageSelectorPseudo)
fn visit_page_selector_pseudos(&mut self, n: &[PageSelectorPseudo])
§fn visit_page_selector_type(&mut self, n: &PageSelectorType)
fn visit_page_selector_type(&mut self, n: &PageSelectorType)
fn visit_page_selectors(&mut self, n: &[PageSelector])
§fn visit_percentage(&mut self, n: &Percentage)
fn visit_percentage(&mut self, n: &Percentage)
§fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)
fn visit_pseudo_class_selector(&mut self, n: &PseudoClassSelector)
§fn visit_pseudo_class_selector_children(
&mut self,
n: &PseudoClassSelectorChildren
)
fn visit_pseudo_class_selector_children( &mut self, n: &PseudoClassSelectorChildren )
fn visit_pseudo_class_selector_children_vec( &mut self, n: &[PseudoClassSelectorChildren] )
§fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)
fn visit_pseudo_element_selector(&mut self, n: &PseudoElementSelector)
§fn visit_pseudo_element_selector_children(
&mut self,
n: &PseudoElementSelectorChildren
)
fn visit_pseudo_element_selector_children( &mut self, n: &PseudoElementSelectorChildren )
fn visit_pseudo_element_selector_children_vec( &mut self, n: &[PseudoElementSelectorChildren] )
§fn visit_qualified_rule(&mut self, n: &QualifiedRule)
fn visit_qualified_rule(&mut self, n: &QualifiedRule)
§fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)
fn visit_qualified_rule_prelude(&mut self, n: &QualifiedRulePrelude)
§fn visit_query_in_parens(&mut self, n: &QueryInParens)
fn visit_query_in_parens(&mut self, n: &QueryInParens)
§fn visit_ratio(&mut self, n: &Ratio)
fn visit_ratio(&mut self, n: &Ratio)
§fn visit_relative_selector(&mut self, n: &RelativeSelector)
fn visit_relative_selector(&mut self, n: &RelativeSelector)
§fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)
fn visit_relative_selector_list(&mut self, n: &RelativeSelectorList)
fn visit_relative_selectors(&mut self, n: &[RelativeSelector])
§fn visit_resolution(&mut self, n: &Resolution)
fn visit_resolution(&mut self, n: &Resolution)
§fn visit_rule(&mut self, n: &Rule)
fn visit_rule(&mut self, n: &Rule)
fn visit_rules(&mut self, n: &[Rule])
§fn visit_scope_range(&mut self, n: &ScopeRange)
fn visit_scope_range(&mut self, n: &ScopeRange)
§fn visit_selector_list(&mut self, n: &SelectorList)
fn visit_selector_list(&mut self, n: &SelectorList)
§fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)
fn visit_sequence_of_custom_idents(&mut self, n: &SequenceOfCustomIdents)
§fn visit_simple_block(&mut self, n: &SimpleBlock)
fn visit_simple_block(&mut self, n: &SimpleBlock)
§fn visit_size_feature(&mut self, n: &SizeFeature)
fn visit_size_feature(&mut self, n: &SizeFeature)
§fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)
fn visit_size_feature_boolean(&mut self, n: &SizeFeatureBoolean)
§fn visit_size_feature_name(&mut self, n: &SizeFeatureName)
fn visit_size_feature_name(&mut self, n: &SizeFeatureName)
§fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)
fn visit_size_feature_plain(&mut self, n: &SizeFeaturePlain)
§fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)
fn visit_size_feature_range(&mut self, n: &SizeFeatureRange)
§fn visit_size_feature_range_comparison(
&mut self,
n: &SizeFeatureRangeComparison
)
fn visit_size_feature_range_comparison( &mut self, n: &SizeFeatureRangeComparison )
§fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)
fn visit_size_feature_range_interval(&mut self, n: &SizeFeatureRangeInterval)
§fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)
fn visit_size_feature_value(&mut self, n: &SizeFeatureValue)
fn visit_span(&mut self, n: &Span)
§fn visit_style_block(&mut self, n: &StyleBlock)
fn visit_style_block(&mut self, n: &StyleBlock)
§fn visit_stylesheet(&mut self, n: &Stylesheet)
fn visit_stylesheet(&mut self, n: &Stylesheet)
§fn visit_subclass_selector(&mut self, n: &SubclassSelector)
fn visit_subclass_selector(&mut self, n: &SubclassSelector)
fn visit_subclass_selectors(&mut self, n: &[SubclassSelector])
§fn visit_supports_and(&mut self, n: &SupportsAnd)
fn visit_supports_and(&mut self, n: &SupportsAnd)
§fn visit_supports_condition(&mut self, n: &SupportsCondition)
fn visit_supports_condition(&mut self, n: &SupportsCondition)
§fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)
fn visit_supports_condition_type(&mut self, n: &SupportsConditionType)
fn visit_supports_condition_types(&mut self, n: &[SupportsConditionType])
§fn visit_supports_feature(&mut self, n: &SupportsFeature)
fn visit_supports_feature(&mut self, n: &SupportsFeature)
§fn visit_supports_in_parens(&mut self, n: &SupportsInParens)
fn visit_supports_in_parens(&mut self, n: &SupportsInParens)
§fn visit_supports_not(&mut self, n: &SupportsNot)
fn visit_supports_not(&mut self, n: &SupportsNot)
§fn visit_supports_or(&mut self, n: &SupportsOr)
fn visit_supports_or(&mut self, n: &SupportsOr)
§fn visit_tag_name_selector(&mut self, n: &TagNameSelector)
fn visit_tag_name_selector(&mut self, n: &TagNameSelector)
§fn visit_time(&mut self, n: &Time)
fn visit_time(&mut self, n: &Time)
§fn visit_time_percentage(&mut self, n: &TimePercentage)
fn visit_time_percentage(&mut self, n: &TimePercentage)
fn visit_token(&mut self, n: &Token)
§fn visit_token_and_span(&mut self, n: &TokenAndSpan)
fn visit_token_and_span(&mut self, n: &TokenAndSpan)
§fn visit_type_selector(&mut self, n: &TypeSelector)
fn visit_type_selector(&mut self, n: &TypeSelector)
§fn visit_unicode_range(&mut self, n: &UnicodeRange)
fn visit_unicode_range(&mut self, n: &UnicodeRange)
§fn visit_universal_selector(&mut self, n: &UniversalSelector)
fn visit_universal_selector(&mut self, n: &UniversalSelector)
§fn visit_unknown_dimension(&mut self, n: &UnknownDimension)
fn visit_unknown_dimension(&mut self, n: &UnknownDimension)
§fn visit_url_modifier(&mut self, n: &UrlModifier)
fn visit_url_modifier(&mut self, n: &UrlModifier)
fn visit_url_modifiers(&mut self, n: &[UrlModifier])
§fn visit_url_value(&mut self, n: &UrlValue)
fn visit_url_value(&mut self, n: &UrlValue)
§fn visit_url_value_raw(&mut self, n: &UrlValueRaw)
fn visit_url_value_raw(&mut self, n: &UrlValueRaw)
§fn visit_wq_name(&mut self, n: &WqName)
fn visit_wq_name(&mut self, n: &WqName)
§impl<A, B> VisitMut for Either<A, B>
impl<A, B> VisitMut for Either<A, B>
§fn visit_mut_accessibility(&mut self, n: &mut Accessibility)
fn visit_mut_accessibility(&mut self, n: &mut Accessibility)
§fn visit_mut_array_lit(&mut self, n: &mut ArrayLit)
fn visit_mut_array_lit(&mut self, n: &mut ArrayLit)
§fn visit_mut_array_pat(&mut self, n: &mut ArrayPat)
fn visit_mut_array_pat(&mut self, n: &mut ArrayPat)
§fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr)
fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr)
§fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr)
fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr)
§fn visit_mut_assign_op(&mut self, n: &mut AssignOp)
fn visit_mut_assign_op(&mut self, n: &mut AssignOp)
§fn visit_mut_assign_pat(&mut self, n: &mut AssignPat)
fn visit_mut_assign_pat(&mut self, n: &mut AssignPat)
§fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp)
fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp)
§fn visit_mut_assign_prop(&mut self, n: &mut AssignProp)
fn visit_mut_assign_prop(&mut self, n: &mut AssignProp)
§fn visit_mut_assign_target(&mut self, n: &mut AssignTarget)
fn visit_mut_assign_target(&mut self, n: &mut AssignTarget)
§fn visit_mut_assign_target_pat(&mut self, n: &mut AssignTargetPat)
fn visit_mut_assign_target_pat(&mut self, n: &mut AssignTargetPat)
fn visit_mut_atom(&mut self, n: &mut Atom)
§fn visit_mut_auto_accessor(&mut self, n: &mut AutoAccessor)
fn visit_mut_auto_accessor(&mut self, n: &mut AutoAccessor)
§fn visit_mut_await_expr(&mut self, n: &mut AwaitExpr)
fn visit_mut_await_expr(&mut self, n: &mut AwaitExpr)
§fn visit_mut_big_int(&mut self, n: &mut BigInt)
fn visit_mut_big_int(&mut self, n: &mut BigInt)
fn visit_mut_big_int_value(&mut self, n: &mut BigInt)
§fn visit_mut_bin_expr(&mut self, n: &mut BinExpr)
fn visit_mut_bin_expr(&mut self, n: &mut BinExpr)
§fn visit_mut_binary_op(&mut self, n: &mut BinaryOp)
fn visit_mut_binary_op(&mut self, n: &mut BinaryOp)
§fn visit_mut_binding_ident(&mut self, n: &mut BindingIdent)
fn visit_mut_binding_ident(&mut self, n: &mut BindingIdent)
§fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt)
fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt)
§fn visit_mut_block_stmt_or_expr(&mut self, n: &mut BlockStmtOrExpr)
fn visit_mut_block_stmt_or_expr(&mut self, n: &mut BlockStmtOrExpr)
§fn visit_mut_bool(&mut self, n: &mut Bool)
fn visit_mut_bool(&mut self, n: &mut Bool)
§fn visit_mut_break_stmt(&mut self, n: &mut BreakStmt)
fn visit_mut_break_stmt(&mut self, n: &mut BreakStmt)
§fn visit_mut_call_expr(&mut self, n: &mut CallExpr)
fn visit_mut_call_expr(&mut self, n: &mut CallExpr)
§fn visit_mut_callee(&mut self, n: &mut Callee)
fn visit_mut_callee(&mut self, n: &mut Callee)
§fn visit_mut_catch_clause(&mut self, n: &mut CatchClause)
fn visit_mut_catch_clause(&mut self, n: &mut CatchClause)
§fn visit_mut_class(&mut self, n: &mut Class)
fn visit_mut_class(&mut self, n: &mut Class)
§fn visit_mut_class_decl(&mut self, n: &mut ClassDecl)
fn visit_mut_class_decl(&mut self, n: &mut ClassDecl)
§fn visit_mut_class_expr(&mut self, n: &mut ClassExpr)
fn visit_mut_class_expr(&mut self, n: &mut ClassExpr)
§fn visit_mut_class_member(&mut self, n: &mut ClassMember)
fn visit_mut_class_member(&mut self, n: &mut ClassMember)
fn visit_mut_class_members(&mut self, n: &mut Vec<ClassMember>)
§fn visit_mut_class_method(&mut self, n: &mut ClassMethod)
fn visit_mut_class_method(&mut self, n: &mut ClassMethod)
§fn visit_mut_class_prop(&mut self, n: &mut ClassProp)
fn visit_mut_class_prop(&mut self, n: &mut ClassProp)
§fn visit_mut_computed_prop_name(&mut self, n: &mut ComputedPropName)
fn visit_mut_computed_prop_name(&mut self, n: &mut ComputedPropName)
§fn visit_mut_cond_expr(&mut self, n: &mut CondExpr)
fn visit_mut_cond_expr(&mut self, n: &mut CondExpr)
§fn visit_mut_constructor(&mut self, n: &mut Constructor)
fn visit_mut_constructor(&mut self, n: &mut Constructor)
§fn visit_mut_continue_stmt(&mut self, n: &mut ContinueStmt)
fn visit_mut_continue_stmt(&mut self, n: &mut ContinueStmt)
§fn visit_mut_debugger_stmt(&mut self, n: &mut DebuggerStmt)
fn visit_mut_debugger_stmt(&mut self, n: &mut DebuggerStmt)
§fn visit_mut_decl(&mut self, n: &mut Decl)
fn visit_mut_decl(&mut self, n: &mut Decl)
§fn visit_mut_decorator(&mut self, n: &mut Decorator)
fn visit_mut_decorator(&mut self, n: &mut Decorator)
fn visit_mut_decorators(&mut self, n: &mut Vec<Decorator>)
§fn visit_mut_default_decl(&mut self, n: &mut DefaultDecl)
fn visit_mut_default_decl(&mut self, n: &mut DefaultDecl)
§fn visit_mut_do_while_stmt(&mut self, n: &mut DoWhileStmt)
fn visit_mut_do_while_stmt(&mut self, n: &mut DoWhileStmt)
§fn visit_mut_empty_stmt(&mut self, n: &mut EmptyStmt)
fn visit_mut_empty_stmt(&mut self, n: &mut EmptyStmt)
§fn visit_mut_export_all(&mut self, n: &mut ExportAll)
fn visit_mut_export_all(&mut self, n: &mut ExportAll)
§fn visit_mut_export_decl(&mut self, n: &mut ExportDecl)
fn visit_mut_export_decl(&mut self, n: &mut ExportDecl)
§fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl)
fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl)
§fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr)
fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr)
§fn visit_mut_export_default_specifier(&mut self, n: &mut ExportDefaultSpecifier)
fn visit_mut_export_default_specifier(&mut self, n: &mut ExportDefaultSpecifier)
§fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier)
fn visit_mut_export_named_specifier(&mut self, n: &mut ExportNamedSpecifier)
§fn visit_mut_export_namespace_specifier(
&mut self,
n: &mut ExportNamespaceSpecifier
)
fn visit_mut_export_namespace_specifier( &mut self, n: &mut ExportNamespaceSpecifier )
§fn visit_mut_export_specifier(&mut self, n: &mut ExportSpecifier)
fn visit_mut_export_specifier(&mut self, n: &mut ExportSpecifier)
fn visit_mut_export_specifiers(&mut self, n: &mut Vec<ExportSpecifier>)
§fn visit_mut_expr(&mut self, n: &mut Expr)
fn visit_mut_expr(&mut self, n: &mut Expr)
§fn visit_mut_expr_or_spread(&mut self, n: &mut ExprOrSpread)
fn visit_mut_expr_or_spread(&mut self, n: &mut ExprOrSpread)
fn visit_mut_expr_or_spreads(&mut self, n: &mut Vec<ExprOrSpread>)
§fn visit_mut_expr_stmt(&mut self, n: &mut ExprStmt)
fn visit_mut_expr_stmt(&mut self, n: &mut ExprStmt)
fn visit_mut_exprs(&mut self, n: &mut Vec<Box<Expr>>)
§fn visit_mut_fn_decl(&mut self, n: &mut FnDecl)
fn visit_mut_fn_decl(&mut self, n: &mut FnDecl)
§fn visit_mut_fn_expr(&mut self, n: &mut FnExpr)
fn visit_mut_fn_expr(&mut self, n: &mut FnExpr)
§fn visit_mut_for_head(&mut self, n: &mut ForHead)
fn visit_mut_for_head(&mut self, n: &mut ForHead)
§fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt)
fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt)
§fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt)
fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt)
§fn visit_mut_for_stmt(&mut self, n: &mut ForStmt)
fn visit_mut_for_stmt(&mut self, n: &mut ForStmt)
§fn visit_mut_function(&mut self, n: &mut Function)
fn visit_mut_function(&mut self, n: &mut Function)
§fn visit_mut_getter_prop(&mut self, n: &mut GetterProp)
fn visit_mut_getter_prop(&mut self, n: &mut GetterProp)
§fn visit_mut_ident(&mut self, n: &mut Ident)
fn visit_mut_ident(&mut self, n: &mut Ident)
§fn visit_mut_if_stmt(&mut self, n: &mut IfStmt)
fn visit_mut_if_stmt(&mut self, n: &mut IfStmt)
§fn visit_mut_import(&mut self, n: &mut Import)
fn visit_mut_import(&mut self, n: &mut Import)
§fn visit_mut_import_decl(&mut self, n: &mut ImportDecl)
fn visit_mut_import_decl(&mut self, n: &mut ImportDecl)
§fn visit_mut_import_default_specifier(&mut self, n: &mut ImportDefaultSpecifier)
fn visit_mut_import_default_specifier(&mut self, n: &mut ImportDefaultSpecifier)
§fn visit_mut_import_named_specifier(&mut self, n: &mut ImportNamedSpecifier)
fn visit_mut_import_named_specifier(&mut self, n: &mut ImportNamedSpecifier)
fn visit_mut_import_phase(&mut self, n: &mut ImportPhase)
§fn visit_mut_import_specifier(&mut self, n: &mut ImportSpecifier)
fn visit_mut_import_specifier(&mut self, n: &mut ImportSpecifier)
fn visit_mut_import_specifiers(&mut self, n: &mut Vec<ImportSpecifier>)
§fn visit_mut_import_star_as_specifier(&mut self, n: &mut ImportStarAsSpecifier)
fn visit_mut_import_star_as_specifier(&mut self, n: &mut ImportStarAsSpecifier)
§fn visit_mut_invalid(&mut self, n: &mut Invalid)
fn visit_mut_invalid(&mut self, n: &mut Invalid)
§fn visit_mut_jsx_attr(&mut self, n: &mut JSXAttr)
fn visit_mut_jsx_attr(&mut self, n: &mut JSXAttr)
§fn visit_mut_jsx_attr_name(&mut self, n: &mut JSXAttrName)
fn visit_mut_jsx_attr_name(&mut self, n: &mut JSXAttrName)
§fn visit_mut_jsx_attr_or_spread(&mut self, n: &mut JSXAttrOrSpread)
fn visit_mut_jsx_attr_or_spread(&mut self, n: &mut JSXAttrOrSpread)
fn visit_mut_jsx_attr_or_spreads(&mut self, n: &mut Vec<JSXAttrOrSpread>)
§fn visit_mut_jsx_attr_value(&mut self, n: &mut JSXAttrValue)
fn visit_mut_jsx_attr_value(&mut self, n: &mut JSXAttrValue)
§fn visit_mut_jsx_closing_element(&mut self, n: &mut JSXClosingElement)
fn visit_mut_jsx_closing_element(&mut self, n: &mut JSXClosingElement)
§fn visit_mut_jsx_closing_fragment(&mut self, n: &mut JSXClosingFragment)
fn visit_mut_jsx_closing_fragment(&mut self, n: &mut JSXClosingFragment)
§fn visit_mut_jsx_element(&mut self, n: &mut JSXElement)
fn visit_mut_jsx_element(&mut self, n: &mut JSXElement)
§fn visit_mut_jsx_element_child(&mut self, n: &mut JSXElementChild)
fn visit_mut_jsx_element_child(&mut self, n: &mut JSXElementChild)
fn visit_mut_jsx_element_children(&mut self, n: &mut Vec<JSXElementChild>)
§fn visit_mut_jsx_element_name(&mut self, n: &mut JSXElementName)
fn visit_mut_jsx_element_name(&mut self, n: &mut JSXElementName)
§fn visit_mut_jsx_empty_expr(&mut self, n: &mut JSXEmptyExpr)
fn visit_mut_jsx_empty_expr(&mut self, n: &mut JSXEmptyExpr)
§fn visit_mut_jsx_expr(&mut self, n: &mut JSXExpr)
fn visit_mut_jsx_expr(&mut self, n: &mut JSXExpr)
§fn visit_mut_jsx_expr_container(&mut self, n: &mut JSXExprContainer)
fn visit_mut_jsx_expr_container(&mut self, n: &mut JSXExprContainer)
§fn visit_mut_jsx_fragment(&mut self, n: &mut JSXFragment)
fn visit_mut_jsx_fragment(&mut self, n: &mut JSXFragment)
§fn visit_mut_jsx_member_expr(&mut self, n: &mut JSXMemberExpr)
fn visit_mut_jsx_member_expr(&mut self, n: &mut JSXMemberExpr)
§fn visit_mut_jsx_namespaced_name(&mut self, n: &mut JSXNamespacedName)
fn visit_mut_jsx_namespaced_name(&mut self, n: &mut JSXNamespacedName)
§fn visit_mut_jsx_object(&mut self, n: &mut JSXObject)
fn visit_mut_jsx_object(&mut self, n: &mut JSXObject)
§fn visit_mut_jsx_opening_element(&mut self, n: &mut JSXOpeningElement)
fn visit_mut_jsx_opening_element(&mut self, n: &mut JSXOpeningElement)
§fn visit_mut_jsx_opening_fragment(&mut self, n: &mut JSXOpeningFragment)
fn visit_mut_jsx_opening_fragment(&mut self, n: &mut JSXOpeningFragment)
§fn visit_mut_jsx_spread_child(&mut self, n: &mut JSXSpreadChild)
fn visit_mut_jsx_spread_child(&mut self, n: &mut JSXSpreadChild)
§fn visit_mut_jsx_text(&mut self, n: &mut JSXText)
fn visit_mut_jsx_text(&mut self, n: &mut JSXText)
§fn visit_mut_key(&mut self, n: &mut Key)
fn visit_mut_key(&mut self, n: &mut Key)
§fn visit_mut_key_value_pat_prop(&mut self, n: &mut KeyValuePatProp)
fn visit_mut_key_value_pat_prop(&mut self, n: &mut KeyValuePatProp)
§fn visit_mut_key_value_prop(&mut self, n: &mut KeyValueProp)
fn visit_mut_key_value_prop(&mut self, n: &mut KeyValueProp)
§fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt)
fn visit_mut_labeled_stmt(&mut self, n: &mut LabeledStmt)
§fn visit_mut_lit(&mut self, n: &mut Lit)
fn visit_mut_lit(&mut self, n: &mut Lit)
§fn visit_mut_member_expr(&mut self, n: &mut MemberExpr)
fn visit_mut_member_expr(&mut self, n: &mut MemberExpr)
§fn visit_mut_member_prop(&mut self, n: &mut MemberProp)
fn visit_mut_member_prop(&mut self, n: &mut MemberProp)
§fn visit_mut_meta_prop_expr(&mut self, n: &mut MetaPropExpr)
fn visit_mut_meta_prop_expr(&mut self, n: &mut MetaPropExpr)
§fn visit_mut_meta_prop_kind(&mut self, n: &mut MetaPropKind)
fn visit_mut_meta_prop_kind(&mut self, n: &mut MetaPropKind)
§fn visit_mut_method_kind(&mut self, n: &mut MethodKind)
fn visit_mut_method_kind(&mut self, n: &mut MethodKind)
§fn visit_mut_method_prop(&mut self, n: &mut MethodProp)
fn visit_mut_method_prop(&mut self, n: &mut MethodProp)
§fn visit_mut_module(&mut self, n: &mut Module)
fn visit_mut_module(&mut self, n: &mut Module)
§fn visit_mut_module_decl(&mut self, n: &mut ModuleDecl)
fn visit_mut_module_decl(&mut self, n: &mut ModuleDecl)
§fn visit_mut_module_export_name(&mut self, n: &mut ModuleExportName)
fn visit_mut_module_export_name(&mut self, n: &mut ModuleExportName)
§fn visit_mut_module_item(&mut self, n: &mut ModuleItem)
fn visit_mut_module_item(&mut self, n: &mut ModuleItem)
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>)
§fn visit_mut_named_export(&mut self, n: &mut NamedExport)
fn visit_mut_named_export(&mut self, n: &mut NamedExport)
§fn visit_mut_new_expr(&mut self, n: &mut NewExpr)
fn visit_mut_new_expr(&mut self, n: &mut NewExpr)
§fn visit_mut_null(&mut self, n: &mut Null)
fn visit_mut_null(&mut self, n: &mut Null)
§fn visit_mut_number(&mut self, n: &mut Number)
fn visit_mut_number(&mut self, n: &mut Number)
§fn visit_mut_object_lit(&mut self, n: &mut ObjectLit)
fn visit_mut_object_lit(&mut self, n: &mut ObjectLit)
§fn visit_mut_object_pat(&mut self, n: &mut ObjectPat)
fn visit_mut_object_pat(&mut self, n: &mut ObjectPat)
§fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp)
fn visit_mut_object_pat_prop(&mut self, n: &mut ObjectPatProp)
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)
fn visit_mut_opt_call(&mut self, n: &mut OptCall)
fn visit_mut_opt_catch_clause(&mut self, n: &mut Option<CatchClause>)
§fn visit_mut_opt_chain_base(&mut self, n: &mut OptChainBase)
fn visit_mut_opt_chain_base(&mut self, n: &mut OptChainBase)
§fn visit_mut_opt_chain_expr(&mut self, n: &mut OptChainExpr)
fn visit_mut_opt_chain_expr(&mut self, n: &mut OptChainExpr)
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)
fn visit_mut_param(&mut self, n: &mut Param)
§fn visit_mut_param_or_ts_param_prop(&mut self, n: &mut ParamOrTsParamProp)
fn visit_mut_param_or_ts_param_prop(&mut self, n: &mut ParamOrTsParamProp)
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)
fn visit_mut_paren_expr(&mut self, n: &mut ParenExpr)
§fn visit_mut_pat(&mut self, n: &mut Pat)
fn visit_mut_pat(&mut self, n: &mut Pat)
fn visit_mut_pats(&mut self, n: &mut Vec<Pat>)
§fn visit_mut_private_method(&mut self, n: &mut PrivateMethod)
fn visit_mut_private_method(&mut self, n: &mut PrivateMethod)
§fn visit_mut_private_name(&mut self, n: &mut PrivateName)
fn visit_mut_private_name(&mut self, n: &mut PrivateName)
§fn visit_mut_private_prop(&mut self, n: &mut PrivateProp)
fn visit_mut_private_prop(&mut self, n: &mut PrivateProp)
§fn visit_mut_program(&mut self, n: &mut Program)
fn visit_mut_program(&mut self, n: &mut Program)
§fn visit_mut_prop(&mut self, n: &mut Prop)
fn visit_mut_prop(&mut self, n: &mut Prop)
§fn visit_mut_prop_name(&mut self, n: &mut PropName)
fn visit_mut_prop_name(&mut self, n: &mut PropName)
§fn visit_mut_prop_or_spread(&mut self, n: &mut PropOrSpread)
fn visit_mut_prop_or_spread(&mut self, n: &mut PropOrSpread)
fn visit_mut_prop_or_spreads(&mut self, n: &mut Vec<PropOrSpread>)
§fn visit_mut_regex(&mut self, n: &mut Regex)
fn visit_mut_regex(&mut self, n: &mut Regex)
§fn visit_mut_reserved_unused(&mut self, n: &mut ReservedUnused)
fn visit_mut_reserved_unused(&mut self, n: &mut ReservedUnused)
§fn visit_mut_rest_pat(&mut self, n: &mut RestPat)
fn visit_mut_rest_pat(&mut self, n: &mut RestPat)
§fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt)
fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt)
§fn visit_mut_script(&mut self, n: &mut Script)
fn visit_mut_script(&mut self, n: &mut Script)
§fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr)
fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr)
§fn visit_mut_setter_prop(&mut self, n: &mut SetterProp)
fn visit_mut_setter_prop(&mut self, n: &mut SetterProp)
§fn visit_mut_simple_assign_target(&mut self, n: &mut SimpleAssignTarget)
fn visit_mut_simple_assign_target(&mut self, n: &mut SimpleAssignTarget)
fn visit_mut_span(&mut self, n: &mut Span)
§fn visit_mut_spread_element(&mut self, n: &mut SpreadElement)
fn visit_mut_spread_element(&mut self, n: &mut SpreadElement)
§fn visit_mut_static_block(&mut self, n: &mut StaticBlock)
fn visit_mut_static_block(&mut self, n: &mut StaticBlock)
§fn visit_mut_stmt(&mut self, n: &mut Stmt)
fn visit_mut_stmt(&mut self, n: &mut Stmt)
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>)
§fn visit_mut_str(&mut self, n: &mut Str)
fn visit_mut_str(&mut self, n: &mut Str)
§fn visit_mut_super(&mut self, n: &mut Super)
fn visit_mut_super(&mut self, n: &mut Super)
§fn visit_mut_super_prop(&mut self, n: &mut SuperProp)
fn visit_mut_super_prop(&mut self, n: &mut SuperProp)
§fn visit_mut_super_prop_expr(&mut self, n: &mut SuperPropExpr)
fn visit_mut_super_prop_expr(&mut self, n: &mut SuperPropExpr)
§fn visit_mut_switch_case(&mut self, n: &mut SwitchCase)
fn visit_mut_switch_case(&mut self, n: &mut SwitchCase)
fn visit_mut_switch_cases(&mut self, n: &mut Vec<SwitchCase>)
§fn visit_mut_switch_stmt(&mut self, n: &mut SwitchStmt)
fn visit_mut_switch_stmt(&mut self, n: &mut SwitchStmt)
§fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl)
fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl)
§fn visit_mut_this_expr(&mut self, n: &mut ThisExpr)
fn visit_mut_this_expr(&mut self, n: &mut ThisExpr)
§fn visit_mut_throw_stmt(&mut self, n: &mut ThrowStmt)
fn visit_mut_throw_stmt(&mut self, n: &mut ThrowStmt)
§fn visit_mut_tpl(&mut self, n: &mut Tpl)
fn visit_mut_tpl(&mut self, n: &mut Tpl)
§fn visit_mut_tpl_element(&mut self, n: &mut TplElement)
fn visit_mut_tpl_element(&mut self, n: &mut TplElement)
fn visit_mut_tpl_elements(&mut self, n: &mut Vec<TplElement>)
§fn visit_mut_true_plus_minus(&mut self, n: &mut TruePlusMinus)
fn visit_mut_true_plus_minus(&mut self, n: &mut TruePlusMinus)
§fn visit_mut_try_stmt(&mut self, n: &mut TryStmt)
fn visit_mut_try_stmt(&mut self, n: &mut TryStmt)
§fn visit_mut_ts_array_type(&mut self, n: &mut TsArrayType)
fn visit_mut_ts_array_type(&mut self, n: &mut TsArrayType)
§fn visit_mut_ts_as_expr(&mut self, n: &mut TsAsExpr)
fn visit_mut_ts_as_expr(&mut self, n: &mut TsAsExpr)
§fn visit_mut_ts_call_signature_decl(&mut self, n: &mut TsCallSignatureDecl)
fn visit_mut_ts_call_signature_decl(&mut self, n: &mut TsCallSignatureDecl)
§fn visit_mut_ts_conditional_type(&mut self, n: &mut TsConditionalType)
fn visit_mut_ts_conditional_type(&mut self, n: &mut TsConditionalType)
§fn visit_mut_ts_const_assertion(&mut self, n: &mut TsConstAssertion)
fn visit_mut_ts_const_assertion(&mut self, n: &mut TsConstAssertion)
§fn visit_mut_ts_construct_signature_decl(
&mut self,
n: &mut TsConstructSignatureDecl
)
fn visit_mut_ts_construct_signature_decl( &mut self, n: &mut TsConstructSignatureDecl )
§fn visit_mut_ts_constructor_type(&mut self, n: &mut TsConstructorType)
fn visit_mut_ts_constructor_type(&mut self, n: &mut TsConstructorType)
§fn visit_mut_ts_entity_name(&mut self, n: &mut TsEntityName)
fn visit_mut_ts_entity_name(&mut self, n: &mut TsEntityName)
§fn visit_mut_ts_enum_decl(&mut self, n: &mut TsEnumDecl)
fn visit_mut_ts_enum_decl(&mut self, n: &mut TsEnumDecl)
§fn visit_mut_ts_enum_member(&mut self, n: &mut TsEnumMember)
fn visit_mut_ts_enum_member(&mut self, n: &mut TsEnumMember)
§fn visit_mut_ts_enum_member_id(&mut self, n: &mut TsEnumMemberId)
fn visit_mut_ts_enum_member_id(&mut self, n: &mut TsEnumMemberId)
fn visit_mut_ts_enum_members(&mut self, n: &mut Vec<TsEnumMember>)
§fn visit_mut_ts_export_assignment(&mut self, n: &mut TsExportAssignment)
fn visit_mut_ts_export_assignment(&mut self, n: &mut TsExportAssignment)
§fn visit_mut_ts_expr_with_type_args(&mut self, n: &mut TsExprWithTypeArgs)
fn visit_mut_ts_expr_with_type_args(&mut self, n: &mut TsExprWithTypeArgs)
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)
fn visit_mut_ts_external_module_ref(&mut self, n: &mut TsExternalModuleRef)
§fn visit_mut_ts_fn_or_constructor_type(&mut self, n: &mut TsFnOrConstructorType)
fn visit_mut_ts_fn_or_constructor_type(&mut self, n: &mut TsFnOrConstructorType)
§fn visit_mut_ts_fn_param(&mut self, n: &mut TsFnParam)
fn visit_mut_ts_fn_param(&mut self, n: &mut TsFnParam)
fn visit_mut_ts_fn_params(&mut self, n: &mut Vec<TsFnParam>)
§fn visit_mut_ts_fn_type(&mut self, n: &mut TsFnType)
fn visit_mut_ts_fn_type(&mut self, n: &mut TsFnType)
§fn visit_mut_ts_getter_signature(&mut self, n: &mut TsGetterSignature)
fn visit_mut_ts_getter_signature(&mut self, n: &mut TsGetterSignature)
§fn visit_mut_ts_import_equals_decl(&mut self, n: &mut TsImportEqualsDecl)
fn visit_mut_ts_import_equals_decl(&mut self, n: &mut TsImportEqualsDecl)
§fn visit_mut_ts_import_type(&mut self, n: &mut TsImportType)
fn visit_mut_ts_import_type(&mut self, n: &mut TsImportType)
§fn visit_mut_ts_index_signature(&mut self, n: &mut TsIndexSignature)
fn visit_mut_ts_index_signature(&mut self, n: &mut TsIndexSignature)
§fn visit_mut_ts_indexed_access_type(&mut self, n: &mut TsIndexedAccessType)
fn visit_mut_ts_indexed_access_type(&mut self, n: &mut TsIndexedAccessType)
§fn visit_mut_ts_infer_type(&mut self, n: &mut TsInferType)
fn visit_mut_ts_infer_type(&mut self, n: &mut TsInferType)
§fn visit_mut_ts_instantiation(&mut self, n: &mut TsInstantiation)
fn visit_mut_ts_instantiation(&mut self, n: &mut TsInstantiation)
§fn visit_mut_ts_interface_body(&mut self, n: &mut TsInterfaceBody)
fn visit_mut_ts_interface_body(&mut self, n: &mut TsInterfaceBody)
§fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl)
fn visit_mut_ts_interface_decl(&mut self, n: &mut TsInterfaceDecl)
§fn visit_mut_ts_intersection_type(&mut self, n: &mut TsIntersectionType)
fn visit_mut_ts_intersection_type(&mut self, n: &mut TsIntersectionType)
§fn visit_mut_ts_keyword_type(&mut self, n: &mut TsKeywordType)
fn visit_mut_ts_keyword_type(&mut self, n: &mut TsKeywordType)
§fn visit_mut_ts_keyword_type_kind(&mut self, n: &mut TsKeywordTypeKind)
fn visit_mut_ts_keyword_type_kind(&mut self, n: &mut TsKeywordTypeKind)
§fn visit_mut_ts_lit(&mut self, n: &mut TsLit)
fn visit_mut_ts_lit(&mut self, n: &mut TsLit)
§fn visit_mut_ts_lit_type(&mut self, n: &mut TsLitType)
fn visit_mut_ts_lit_type(&mut self, n: &mut TsLitType)
§fn visit_mut_ts_mapped_type(&mut self, n: &mut TsMappedType)
fn visit_mut_ts_mapped_type(&mut self, n: &mut TsMappedType)
§fn visit_mut_ts_method_signature(&mut self, n: &mut TsMethodSignature)
fn visit_mut_ts_method_signature(&mut self, n: &mut TsMethodSignature)
§fn visit_mut_ts_module_block(&mut self, n: &mut TsModuleBlock)
fn visit_mut_ts_module_block(&mut self, n: &mut TsModuleBlock)
§fn visit_mut_ts_module_decl(&mut self, n: &mut TsModuleDecl)
fn visit_mut_ts_module_decl(&mut self, n: &mut TsModuleDecl)
§fn visit_mut_ts_module_name(&mut self, n: &mut TsModuleName)
fn visit_mut_ts_module_name(&mut self, n: &mut TsModuleName)
§fn visit_mut_ts_module_ref(&mut self, n: &mut TsModuleRef)
fn visit_mut_ts_module_ref(&mut self, n: &mut TsModuleRef)
§fn visit_mut_ts_namespace_body(&mut self, n: &mut TsNamespaceBody)
fn visit_mut_ts_namespace_body(&mut self, n: &mut TsNamespaceBody)
§fn visit_mut_ts_namespace_decl(&mut self, n: &mut TsNamespaceDecl)
fn visit_mut_ts_namespace_decl(&mut self, n: &mut TsNamespaceDecl)
§fn visit_mut_ts_namespace_export_decl(&mut self, n: &mut TsNamespaceExportDecl)
fn visit_mut_ts_namespace_export_decl(&mut self, n: &mut TsNamespaceExportDecl)
§fn visit_mut_ts_non_null_expr(&mut self, n: &mut TsNonNullExpr)
fn visit_mut_ts_non_null_expr(&mut self, n: &mut TsNonNullExpr)
§fn visit_mut_ts_optional_type(&mut self, n: &mut TsOptionalType)
fn visit_mut_ts_optional_type(&mut self, n: &mut TsOptionalType)
§fn visit_mut_ts_param_prop(&mut self, n: &mut TsParamProp)
fn visit_mut_ts_param_prop(&mut self, n: &mut TsParamProp)
§fn visit_mut_ts_param_prop_param(&mut self, n: &mut TsParamPropParam)
fn visit_mut_ts_param_prop_param(&mut self, n: &mut TsParamPropParam)
§fn visit_mut_ts_parenthesized_type(&mut self, n: &mut TsParenthesizedType)
fn visit_mut_ts_parenthesized_type(&mut self, n: &mut TsParenthesizedType)
§fn visit_mut_ts_property_signature(&mut self, n: &mut TsPropertySignature)
fn visit_mut_ts_property_signature(&mut self, n: &mut TsPropertySignature)
§fn visit_mut_ts_qualified_name(&mut self, n: &mut TsQualifiedName)
fn visit_mut_ts_qualified_name(&mut self, n: &mut TsQualifiedName)
§fn visit_mut_ts_rest_type(&mut self, n: &mut TsRestType)
fn visit_mut_ts_rest_type(&mut self, n: &mut TsRestType)
§fn visit_mut_ts_satisfies_expr(&mut self, n: &mut TsSatisfiesExpr)
fn visit_mut_ts_satisfies_expr(&mut self, n: &mut TsSatisfiesExpr)
§fn visit_mut_ts_setter_signature(&mut self, n: &mut TsSetterSignature)
fn visit_mut_ts_setter_signature(&mut self, n: &mut TsSetterSignature)
§fn visit_mut_ts_this_type(&mut self, n: &mut TsThisType)
fn visit_mut_ts_this_type(&mut self, n: &mut TsThisType)
§fn visit_mut_ts_this_type_or_ident(&mut self, n: &mut TsThisTypeOrIdent)
fn visit_mut_ts_this_type_or_ident(&mut self, n: &mut TsThisTypeOrIdent)
§fn visit_mut_ts_tpl_lit_type(&mut self, n: &mut TsTplLitType)
fn visit_mut_ts_tpl_lit_type(&mut self, n: &mut TsTplLitType)
§fn visit_mut_ts_tuple_element(&mut self, n: &mut TsTupleElement)
fn visit_mut_ts_tuple_element(&mut self, n: &mut TsTupleElement)
fn visit_mut_ts_tuple_elements(&mut self, n: &mut Vec<TsTupleElement>)
§fn visit_mut_ts_tuple_type(&mut self, n: &mut TsTupleType)
fn visit_mut_ts_tuple_type(&mut self, n: &mut TsTupleType)
§fn visit_mut_ts_type(&mut self, n: &mut TsType)
fn visit_mut_ts_type(&mut self, n: &mut TsType)
§fn visit_mut_ts_type_alias_decl(&mut self, n: &mut TsTypeAliasDecl)
fn visit_mut_ts_type_alias_decl(&mut self, n: &mut TsTypeAliasDecl)
§fn visit_mut_ts_type_ann(&mut self, n: &mut TsTypeAnn)
fn visit_mut_ts_type_ann(&mut self, n: &mut TsTypeAnn)
§fn visit_mut_ts_type_assertion(&mut self, n: &mut TsTypeAssertion)
fn visit_mut_ts_type_assertion(&mut self, n: &mut TsTypeAssertion)
§fn visit_mut_ts_type_element(&mut self, n: &mut TsTypeElement)
fn visit_mut_ts_type_element(&mut self, n: &mut TsTypeElement)
fn visit_mut_ts_type_elements(&mut self, n: &mut Vec<TsTypeElement>)
§fn visit_mut_ts_type_lit(&mut self, n: &mut TsTypeLit)
fn visit_mut_ts_type_lit(&mut self, n: &mut TsTypeLit)
§fn visit_mut_ts_type_operator(&mut self, n: &mut TsTypeOperator)
fn visit_mut_ts_type_operator(&mut self, n: &mut TsTypeOperator)
§fn visit_mut_ts_type_operator_op(&mut self, n: &mut TsTypeOperatorOp)
fn visit_mut_ts_type_operator_op(&mut self, n: &mut TsTypeOperatorOp)
§fn visit_mut_ts_type_param(&mut self, n: &mut TsTypeParam)
fn visit_mut_ts_type_param(&mut self, n: &mut TsTypeParam)
§fn visit_mut_ts_type_param_decl(&mut self, n: &mut TsTypeParamDecl)
fn visit_mut_ts_type_param_decl(&mut self, n: &mut TsTypeParamDecl)
§fn visit_mut_ts_type_param_instantiation(
&mut self,
n: &mut TsTypeParamInstantiation
)
fn visit_mut_ts_type_param_instantiation( &mut self, n: &mut TsTypeParamInstantiation )
fn visit_mut_ts_type_params(&mut self, n: &mut Vec<TsTypeParam>)
§fn visit_mut_ts_type_predicate(&mut self, n: &mut TsTypePredicate)
fn visit_mut_ts_type_predicate(&mut self, n: &mut TsTypePredicate)
§fn visit_mut_ts_type_query(&mut self, n: &mut TsTypeQuery)
fn visit_mut_ts_type_query(&mut self, n: &mut TsTypeQuery)
§fn visit_mut_ts_type_query_expr(&mut self, n: &mut TsTypeQueryExpr)
fn visit_mut_ts_type_query_expr(&mut self, n: &mut TsTypeQueryExpr)
§fn visit_mut_ts_type_ref(&mut self, n: &mut TsTypeRef)
fn visit_mut_ts_type_ref(&mut self, n: &mut TsTypeRef)
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
)
fn visit_mut_ts_union_or_intersection_type( &mut self, n: &mut TsUnionOrIntersectionType )
§fn visit_mut_ts_union_type(&mut self, n: &mut TsUnionType)
fn visit_mut_ts_union_type(&mut self, n: &mut TsUnionType)
§fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr)
fn visit_mut_unary_expr(&mut self, n: &mut UnaryExpr)
§fn visit_mut_unary_op(&mut self, n: &mut UnaryOp)
fn visit_mut_unary_op(&mut self, n: &mut UnaryOp)
§fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr)
fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr)
§fn visit_mut_update_op(&mut self, n: &mut UpdateOp)
fn visit_mut_update_op(&mut self, n: &mut UpdateOp)
§fn visit_mut_using_decl(&mut self, n: &mut UsingDecl)
fn visit_mut_using_decl(&mut self, n: &mut UsingDecl)
§fn visit_mut_var_decl(&mut self, n: &mut VarDecl)
fn visit_mut_var_decl(&mut self, n: &mut VarDecl)
§fn visit_mut_var_decl_kind(&mut self, n: &mut VarDeclKind)
fn visit_mut_var_decl_kind(&mut self, n: &mut VarDeclKind)
§fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr)
fn visit_mut_var_decl_or_expr(&mut self, n: &mut VarDeclOrExpr)
§fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator)
fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator)
fn visit_mut_var_declarators(&mut self, n: &mut Vec<VarDeclarator>)
§fn visit_mut_while_stmt(&mut self, n: &mut WhileStmt)
fn visit_mut_while_stmt(&mut self, n: &mut WhileStmt)
§fn visit_mut_with_stmt(&mut self, n: &mut WithStmt)
fn visit_mut_with_stmt(&mut self, n: &mut WithStmt)
§fn visit_mut_yield_expr(&mut self, n: &mut YieldExpr)
fn visit_mut_yield_expr(&mut self, n: &mut YieldExpr)
§impl<A, B> VisitMut for Either<A, B>where
A: VisitMut,
B: VisitMut,
impl<A, B> VisitMut for Either<A, B>where
A: VisitMut,
B: VisitMut,
§fn visit_mut_absolute_color_base(&mut self, n: &mut AbsoluteColorBase)
fn visit_mut_absolute_color_base(&mut self, n: &mut AbsoluteColorBase)
§fn visit_mut_alpha_value(&mut self, n: &mut AlphaValue)
fn visit_mut_alpha_value(&mut self, n: &mut AlphaValue)
§fn visit_mut_an_plus_b(&mut self, n: &mut AnPlusB)
fn visit_mut_an_plus_b(&mut self, n: &mut AnPlusB)
§fn visit_mut_an_plus_b_notation(&mut self, n: &mut AnPlusBNotation)
fn visit_mut_an_plus_b_notation(&mut self, n: &mut AnPlusBNotation)
§fn visit_mut_angle(&mut self, n: &mut Angle)
fn visit_mut_angle(&mut self, n: &mut Angle)
§fn visit_mut_angle_percentage(&mut self, n: &mut AnglePercentage)
fn visit_mut_angle_percentage(&mut self, n: &mut AnglePercentage)
§fn visit_mut_any_namespace(&mut self, n: &mut AnyNamespace)
fn visit_mut_any_namespace(&mut self, n: &mut AnyNamespace)
§fn visit_mut_at_rule(&mut self, n: &mut AtRule)
fn visit_mut_at_rule(&mut self, n: &mut AtRule)
§fn visit_mut_at_rule_name(&mut self, n: &mut AtRuleName)
fn visit_mut_at_rule_name(&mut self, n: &mut AtRuleName)
§fn visit_mut_at_rule_prelude(&mut self, n: &mut AtRulePrelude)
fn visit_mut_at_rule_prelude(&mut self, n: &mut AtRulePrelude)
fn visit_mut_atom(&mut self, n: &mut Atom)
§fn visit_mut_attribute_selector(&mut self, n: &mut AttributeSelector)
fn visit_mut_attribute_selector(&mut self, n: &mut AttributeSelector)
§fn visit_mut_attribute_selector_matcher(
&mut self,
n: &mut AttributeSelectorMatcher
)
fn visit_mut_attribute_selector_matcher( &mut self, n: &mut AttributeSelectorMatcher )
fn visit_mut_attribute_selector_matcher_value( &mut self, n: &mut AttributeSelectorMatcherValue )
§fn visit_mut_attribute_selector_modifier(
&mut self,
n: &mut AttributeSelectorModifier
)
fn visit_mut_attribute_selector_modifier( &mut self, n: &mut AttributeSelectorModifier )
§fn visit_mut_attribute_selector_value(&mut self, n: &mut AttributeSelectorValue)
fn visit_mut_attribute_selector_value(&mut self, n: &mut AttributeSelectorValue)
§fn visit_mut_calc_operator(&mut self, n: &mut CalcOperator)
fn visit_mut_calc_operator(&mut self, n: &mut CalcOperator)
§fn visit_mut_calc_operator_type(&mut self, n: &mut CalcOperatorType)
fn visit_mut_calc_operator_type(&mut self, n: &mut CalcOperatorType)
§fn visit_mut_calc_product(&mut self, n: &mut CalcProduct)
fn visit_mut_calc_product(&mut self, n: &mut CalcProduct)
§fn visit_mut_calc_product_or_operator(&mut self, n: &mut CalcProductOrOperator)
fn visit_mut_calc_product_or_operator(&mut self, n: &mut CalcProductOrOperator)
fn visit_mut_calc_product_or_operators( &mut self, n: &mut Vec<CalcProductOrOperator> )
§fn visit_mut_calc_sum(&mut self, n: &mut CalcSum)
fn visit_mut_calc_sum(&mut self, n: &mut CalcSum)
§fn visit_mut_calc_value(&mut self, n: &mut CalcValue)
fn visit_mut_calc_value(&mut self, n: &mut CalcValue)
§fn visit_mut_calc_value_or_operator(&mut self, n: &mut CalcValueOrOperator)
fn visit_mut_calc_value_or_operator(&mut self, n: &mut CalcValueOrOperator)
fn visit_mut_calc_value_or_operators( &mut self, n: &mut Vec<CalcValueOrOperator> )
§fn visit_mut_class_selector(&mut self, n: &mut ClassSelector)
fn visit_mut_class_selector(&mut self, n: &mut ClassSelector)
§fn visit_mut_cmyk_component(&mut self, n: &mut CmykComponent)
fn visit_mut_cmyk_component(&mut self, n: &mut CmykComponent)
§fn visit_mut_color(&mut self, n: &mut Color)
fn visit_mut_color(&mut self, n: &mut Color)
§fn visit_mut_color_profile_name(&mut self, n: &mut ColorProfileName)
fn visit_mut_color_profile_name(&mut self, n: &mut ColorProfileName)
§fn visit_mut_combinator(&mut self, n: &mut Combinator)
fn visit_mut_combinator(&mut self, n: &mut Combinator)
fn visit_mut_combinator_value(&mut self, n: &mut CombinatorValue)
§fn visit_mut_complex_selector(&mut self, n: &mut ComplexSelector)
fn visit_mut_complex_selector(&mut self, n: &mut ComplexSelector)
§fn visit_mut_complex_selector_children(
&mut self,
n: &mut ComplexSelectorChildren
)
fn visit_mut_complex_selector_children( &mut self, n: &mut ComplexSelectorChildren )
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)
fn visit_mut_component_value(&mut self, n: &mut ComponentValue)
fn visit_mut_component_values(&mut self, n: &mut Vec<ComponentValue>)
§fn visit_mut_compound_selector(&mut self, n: &mut CompoundSelector)
fn visit_mut_compound_selector(&mut self, n: &mut CompoundSelector)
§fn visit_mut_compound_selector_list(&mut self, n: &mut CompoundSelectorList)
fn visit_mut_compound_selector_list(&mut self, n: &mut CompoundSelectorList)
fn visit_mut_compound_selectors(&mut self, n: &mut Vec<CompoundSelector>)
§fn visit_mut_container_condition(&mut self, n: &mut ContainerCondition)
fn visit_mut_container_condition(&mut self, n: &mut ContainerCondition)
§fn visit_mut_container_name(&mut self, n: &mut ContainerName)
fn visit_mut_container_name(&mut self, n: &mut ContainerName)
§fn visit_mut_container_query(&mut self, n: &mut ContainerQuery)
fn visit_mut_container_query(&mut self, n: &mut ContainerQuery)
§fn visit_mut_container_query_and(&mut self, n: &mut ContainerQueryAnd)
fn visit_mut_container_query_and(&mut self, n: &mut ContainerQueryAnd)
§fn visit_mut_container_query_not(&mut self, n: &mut ContainerQueryNot)
fn visit_mut_container_query_not(&mut self, n: &mut ContainerQueryNot)
§fn visit_mut_container_query_or(&mut self, n: &mut ContainerQueryOr)
fn visit_mut_container_query_or(&mut self, n: &mut ContainerQueryOr)
§fn visit_mut_container_query_type(&mut self, n: &mut ContainerQueryType)
fn visit_mut_container_query_type(&mut self, n: &mut ContainerQueryType)
fn visit_mut_container_query_types(&mut self, n: &mut Vec<ContainerQueryType>)
§fn visit_mut_custom_highlight_name(&mut self, n: &mut CustomHighlightName)
fn visit_mut_custom_highlight_name(&mut self, n: &mut CustomHighlightName)
§fn visit_mut_custom_ident(&mut self, n: &mut CustomIdent)
fn visit_mut_custom_ident(&mut self, n: &mut CustomIdent)
fn visit_mut_custom_idents(&mut self, n: &mut Vec<CustomIdent>)
§fn visit_mut_custom_media_query(&mut self, n: &mut CustomMediaQuery)
fn visit_mut_custom_media_query(&mut self, n: &mut CustomMediaQuery)
§fn visit_mut_custom_media_query_media_type(
&mut self,
n: &mut CustomMediaQueryMediaType
)
fn visit_mut_custom_media_query_media_type( &mut self, n: &mut CustomMediaQueryMediaType )
§fn visit_mut_custom_property_name(&mut self, n: &mut CustomPropertyName)
fn visit_mut_custom_property_name(&mut self, n: &mut CustomPropertyName)
§fn visit_mut_dashed_ident(&mut self, n: &mut DashedIdent)
fn visit_mut_dashed_ident(&mut self, n: &mut DashedIdent)
§fn visit_mut_declaration(&mut self, n: &mut Declaration)
fn visit_mut_declaration(&mut self, n: &mut Declaration)
§fn visit_mut_declaration_name(&mut self, n: &mut DeclarationName)
fn visit_mut_declaration_name(&mut self, n: &mut DeclarationName)
§fn visit_mut_declaration_or_at_rule(&mut self, n: &mut DeclarationOrAtRule)
fn visit_mut_declaration_or_at_rule(&mut self, n: &mut DeclarationOrAtRule)
§fn visit_mut_delimiter(&mut self, n: &mut Delimiter)
fn visit_mut_delimiter(&mut self, n: &mut Delimiter)
§fn visit_mut_delimiter_value(&mut self, n: &mut DelimiterValue)
fn visit_mut_delimiter_value(&mut self, n: &mut DelimiterValue)
§fn visit_mut_dimension(&mut self, n: &mut Dimension)
fn visit_mut_dimension(&mut self, n: &mut Dimension)
§fn visit_mut_document_prelude(&mut self, n: &mut DocumentPrelude)
fn visit_mut_document_prelude(&mut self, n: &mut DocumentPrelude)
§fn visit_mut_document_prelude_matching_function(
&mut self,
n: &mut DocumentPreludeMatchingFunction
)
fn visit_mut_document_prelude_matching_function( &mut self, n: &mut DocumentPreludeMatchingFunction )
fn visit_mut_document_prelude_matching_functions( &mut self, n: &mut Vec<DocumentPreludeMatchingFunction> )
§fn visit_mut_extension_name(&mut self, n: &mut ExtensionName)
fn visit_mut_extension_name(&mut self, n: &mut ExtensionName)
§fn visit_mut_family_name(&mut self, n: &mut FamilyName)
fn visit_mut_family_name(&mut self, n: &mut FamilyName)
fn visit_mut_family_names(&mut self, n: &mut Vec<FamilyName>)
§fn visit_mut_flex(&mut self, n: &mut Flex)
fn visit_mut_flex(&mut self, n: &mut Flex)
§fn visit_mut_font_feature_values_prelude(
&mut self,
n: &mut FontFeatureValuesPrelude
)
fn visit_mut_font_feature_values_prelude( &mut self, n: &mut FontFeatureValuesPrelude )
§fn visit_mut_forgiving_complex_selector(
&mut self,
n: &mut ForgivingComplexSelector
)
fn visit_mut_forgiving_complex_selector( &mut self, n: &mut ForgivingComplexSelector )
fn visit_mut_forgiving_complex_selectors( &mut self, n: &mut Vec<ForgivingComplexSelector> )
§fn visit_mut_forgiving_relative_selector(
&mut self,
n: &mut ForgivingRelativeSelector
)
fn visit_mut_forgiving_relative_selector( &mut self, n: &mut ForgivingRelativeSelector )
§fn visit_mut_forgiving_relative_selector_list(
&mut self,
n: &mut ForgivingRelativeSelectorList
)
fn visit_mut_forgiving_relative_selector_list( &mut self, n: &mut ForgivingRelativeSelectorList )
fn visit_mut_forgiving_relative_selectors( &mut self, n: &mut Vec<ForgivingRelativeSelector> )
§fn visit_mut_forgiving_selector_list(&mut self, n: &mut ForgivingSelectorList)
fn visit_mut_forgiving_selector_list(&mut self, n: &mut ForgivingSelectorList)
§fn visit_mut_frequency(&mut self, n: &mut Frequency)
fn visit_mut_frequency(&mut self, n: &mut Frequency)
§fn visit_mut_frequency_percentage(&mut self, n: &mut FrequencyPercentage)
fn visit_mut_frequency_percentage(&mut self, n: &mut FrequencyPercentage)
§fn visit_mut_function(&mut self, n: &mut Function)
fn visit_mut_function(&mut self, n: &mut Function)
§fn visit_mut_function_name(&mut self, n: &mut FunctionName)
fn visit_mut_function_name(&mut self, n: &mut FunctionName)
§fn visit_mut_general_enclosed(&mut self, n: &mut GeneralEnclosed)
fn visit_mut_general_enclosed(&mut self, n: &mut GeneralEnclosed)
§fn visit_mut_hex_color(&mut self, n: &mut HexColor)
fn visit_mut_hex_color(&mut self, n: &mut HexColor)
§fn visit_mut_hue(&mut self, n: &mut Hue)
fn visit_mut_hue(&mut self, n: &mut Hue)
fn visit_mut_i_32(&mut self, n: &mut i32)
§fn visit_mut_id_selector(&mut self, n: &mut IdSelector)
fn visit_mut_id_selector(&mut self, n: &mut IdSelector)
§fn visit_mut_ident(&mut self, n: &mut Ident)
fn visit_mut_ident(&mut self, n: &mut Ident)
fn visit_mut_idents(&mut self, n: &mut Vec<Ident>)
§fn visit_mut_import_conditions(&mut self, n: &mut ImportConditions)
fn visit_mut_import_conditions(&mut self, n: &mut ImportConditions)
§fn visit_mut_import_href(&mut self, n: &mut ImportHref)
fn visit_mut_import_href(&mut self, n: &mut ImportHref)
§fn visit_mut_import_layer_name(&mut self, n: &mut ImportLayerName)
fn visit_mut_import_layer_name(&mut self, n: &mut ImportLayerName)
§fn visit_mut_import_prelude(&mut self, n: &mut ImportPrelude)
fn visit_mut_import_prelude(&mut self, n: &mut ImportPrelude)
§fn visit_mut_important_flag(&mut self, n: &mut ImportantFlag)
fn visit_mut_important_flag(&mut self, n: &mut ImportantFlag)
§fn visit_mut_integer(&mut self, n: &mut Integer)
fn visit_mut_integer(&mut self, n: &mut Integer)
§fn visit_mut_keyframe_block(&mut self, n: &mut KeyframeBlock)
fn visit_mut_keyframe_block(&mut self, n: &mut KeyframeBlock)
§fn visit_mut_keyframe_selector(&mut self, n: &mut KeyframeSelector)
fn visit_mut_keyframe_selector(&mut self, n: &mut KeyframeSelector)
fn visit_mut_keyframe_selectors(&mut self, n: &mut Vec<KeyframeSelector>)
§fn visit_mut_keyframes_name(&mut self, n: &mut KeyframesName)
fn visit_mut_keyframes_name(&mut self, n: &mut KeyframesName)
§fn visit_mut_keyframes_pseudo_function(
&mut self,
n: &mut KeyframesPseudoFunction
)
fn visit_mut_keyframes_pseudo_function( &mut self, n: &mut KeyframesPseudoFunction )
§fn visit_mut_keyframes_pseudo_prefix(&mut self, n: &mut KeyframesPseudoPrefix)
fn visit_mut_keyframes_pseudo_prefix(&mut self, n: &mut KeyframesPseudoPrefix)
§fn visit_mut_layer_name(&mut self, n: &mut LayerName)
fn visit_mut_layer_name(&mut self, n: &mut LayerName)
§fn visit_mut_layer_name_list(&mut self, n: &mut LayerNameList)
fn visit_mut_layer_name_list(&mut self, n: &mut LayerNameList)
fn visit_mut_layer_names(&mut self, n: &mut Vec<LayerName>)
§fn visit_mut_layer_prelude(&mut self, n: &mut LayerPrelude)
fn visit_mut_layer_prelude(&mut self, n: &mut LayerPrelude)
§fn visit_mut_length(&mut self, n: &mut Length)
fn visit_mut_length(&mut self, n: &mut Length)
§fn visit_mut_length_percentage(&mut self, n: &mut LengthPercentage)
fn visit_mut_length_percentage(&mut self, n: &mut LengthPercentage)
§fn visit_mut_list_of_component_values(&mut self, n: &mut ListOfComponentValues)
fn visit_mut_list_of_component_values(&mut self, n: &mut ListOfComponentValues)
§fn visit_mut_media_and(&mut self, n: &mut MediaAnd)
fn visit_mut_media_and(&mut self, n: &mut MediaAnd)
§fn visit_mut_media_condition(&mut self, n: &mut MediaCondition)
fn visit_mut_media_condition(&mut self, n: &mut MediaCondition)
§fn visit_mut_media_condition_all_type(&mut self, n: &mut MediaConditionAllType)
fn visit_mut_media_condition_all_type(&mut self, n: &mut MediaConditionAllType)
fn visit_mut_media_condition_all_types( &mut self, n: &mut Vec<MediaConditionAllType> )
§fn visit_mut_media_condition_type(&mut self, n: &mut MediaConditionType)
fn visit_mut_media_condition_type(&mut self, n: &mut MediaConditionType)
§fn visit_mut_media_condition_without_or(
&mut self,
n: &mut MediaConditionWithoutOr
)
fn visit_mut_media_condition_without_or( &mut self, n: &mut MediaConditionWithoutOr )
§fn visit_mut_media_condition_without_or_type(
&mut self,
n: &mut MediaConditionWithoutOrType
)
fn visit_mut_media_condition_without_or_type( &mut self, n: &mut MediaConditionWithoutOrType )
fn visit_mut_media_condition_without_or_types( &mut self, n: &mut Vec<MediaConditionWithoutOrType> )
§fn visit_mut_media_feature(&mut self, n: &mut MediaFeature)
fn visit_mut_media_feature(&mut self, n: &mut MediaFeature)
§fn visit_mut_media_feature_boolean(&mut self, n: &mut MediaFeatureBoolean)
fn visit_mut_media_feature_boolean(&mut self, n: &mut MediaFeatureBoolean)
§fn visit_mut_media_feature_name(&mut self, n: &mut MediaFeatureName)
fn visit_mut_media_feature_name(&mut self, n: &mut MediaFeatureName)
§fn visit_mut_media_feature_plain(&mut self, n: &mut MediaFeaturePlain)
fn visit_mut_media_feature_plain(&mut self, n: &mut MediaFeaturePlain)
§fn visit_mut_media_feature_range(&mut self, n: &mut MediaFeatureRange)
fn visit_mut_media_feature_range(&mut self, n: &mut MediaFeatureRange)
fn visit_mut_media_feature_range_comparison( &mut self, n: &mut MediaFeatureRangeComparison )
§fn visit_mut_media_feature_range_interval(
&mut self,
n: &mut MediaFeatureRangeInterval
)
fn visit_mut_media_feature_range_interval( &mut self, n: &mut MediaFeatureRangeInterval )
§fn visit_mut_media_feature_value(&mut self, n: &mut MediaFeatureValue)
fn visit_mut_media_feature_value(&mut self, n: &mut MediaFeatureValue)
§fn visit_mut_media_in_parens(&mut self, n: &mut MediaInParens)
fn visit_mut_media_in_parens(&mut self, n: &mut MediaInParens)
§fn visit_mut_media_not(&mut self, n: &mut MediaNot)
fn visit_mut_media_not(&mut self, n: &mut MediaNot)
§fn visit_mut_media_or(&mut self, n: &mut MediaOr)
fn visit_mut_media_or(&mut self, n: &mut MediaOr)
fn visit_mut_media_queries(&mut self, n: &mut Vec<MediaQuery>)
§fn visit_mut_media_query(&mut self, n: &mut MediaQuery)
fn visit_mut_media_query(&mut self, n: &mut MediaQuery)
§fn visit_mut_media_query_list(&mut self, n: &mut MediaQueryList)
fn visit_mut_media_query_list(&mut self, n: &mut MediaQueryList)
§fn visit_mut_media_type(&mut self, n: &mut MediaType)
fn visit_mut_media_type(&mut self, n: &mut MediaType)
§fn visit_mut_named_namespace(&mut self, n: &mut NamedNamespace)
fn visit_mut_named_namespace(&mut self, n: &mut NamedNamespace)
§fn visit_mut_namespace(&mut self, n: &mut Namespace)
fn visit_mut_namespace(&mut self, n: &mut Namespace)
§fn visit_mut_namespace_prefix(&mut self, n: &mut NamespacePrefix)
fn visit_mut_namespace_prefix(&mut self, n: &mut NamespacePrefix)
§fn visit_mut_namespace_prelude(&mut self, n: &mut NamespacePrelude)
fn visit_mut_namespace_prelude(&mut self, n: &mut NamespacePrelude)
§fn visit_mut_namespace_prelude_uri(&mut self, n: &mut NamespacePreludeUri)
fn visit_mut_namespace_prelude_uri(&mut self, n: &mut NamespacePreludeUri)
§fn visit_mut_nesting_selector(&mut self, n: &mut NestingSelector)
fn visit_mut_nesting_selector(&mut self, n: &mut NestingSelector)
§fn visit_mut_number(&mut self, n: &mut Number)
fn visit_mut_number(&mut self, n: &mut Number)
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)
fn visit_mut_page_selector(&mut self, n: &mut PageSelector)
§fn visit_mut_page_selector_list(&mut self, n: &mut PageSelectorList)
fn visit_mut_page_selector_list(&mut self, n: &mut PageSelectorList)
§fn visit_mut_page_selector_pseudo(&mut self, n: &mut PageSelectorPseudo)
fn visit_mut_page_selector_pseudo(&mut self, n: &mut PageSelectorPseudo)
fn visit_mut_page_selector_pseudos(&mut self, n: &mut Vec<PageSelectorPseudo>)
§fn visit_mut_page_selector_type(&mut self, n: &mut PageSelectorType)
fn visit_mut_page_selector_type(&mut self, n: &mut PageSelectorType)
fn visit_mut_page_selectors(&mut self, n: &mut Vec<PageSelector>)
§fn visit_mut_percentage(&mut self, n: &mut Percentage)
fn visit_mut_percentage(&mut self, n: &mut Percentage)
§fn visit_mut_pseudo_class_selector(&mut self, n: &mut PseudoClassSelector)
fn visit_mut_pseudo_class_selector(&mut self, n: &mut PseudoClassSelector)
§fn visit_mut_pseudo_class_selector_children(
&mut self,
n: &mut PseudoClassSelectorChildren
)
fn visit_mut_pseudo_class_selector_children( &mut self, n: &mut PseudoClassSelectorChildren )
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)
fn visit_mut_pseudo_element_selector(&mut self, n: &mut PseudoElementSelector)
§fn visit_mut_pseudo_element_selector_children(
&mut self,
n: &mut PseudoElementSelectorChildren
)
fn visit_mut_pseudo_element_selector_children( &mut self, n: &mut PseudoElementSelectorChildren )
fn visit_mut_pseudo_element_selector_children_vec( &mut self, n: &mut Vec<PseudoElementSelectorChildren> )
§fn visit_mut_qualified_rule(&mut self, n: &mut QualifiedRule)
fn visit_mut_qualified_rule(&mut self, n: &mut QualifiedRule)
§fn visit_mut_qualified_rule_prelude(&mut self, n: &mut QualifiedRulePrelude)
fn visit_mut_qualified_rule_prelude(&mut self, n: &mut QualifiedRulePrelude)
§fn visit_mut_query_in_parens(&mut self, n: &mut QueryInParens)
fn visit_mut_query_in_parens(&mut self, n: &mut QueryInParens)
§fn visit_mut_ratio(&mut self, n: &mut Ratio)
fn visit_mut_ratio(&mut self, n: &mut Ratio)
§fn visit_mut_relative_selector(&mut self, n: &mut RelativeSelector)
fn visit_mut_relative_selector(&mut self, n: &mut RelativeSelector)
§fn visit_mut_relative_selector_list(&mut self, n: &mut RelativeSelectorList)
fn visit_mut_relative_selector_list(&mut self, n: &mut RelativeSelectorList)
fn visit_mut_relative_selectors(&mut self, n: &mut Vec<RelativeSelector>)
§fn visit_mut_resolution(&mut self, n: &mut Resolution)
fn visit_mut_resolution(&mut self, n: &mut Resolution)
§fn visit_mut_rule(&mut self, n: &mut Rule)
fn visit_mut_rule(&mut self, n: &mut Rule)
fn visit_mut_rules(&mut self, n: &mut Vec<Rule>)
§fn visit_mut_scope_range(&mut self, n: &mut ScopeRange)
fn visit_mut_scope_range(&mut self, n: &mut ScopeRange)
§fn visit_mut_selector_list(&mut self, n: &mut SelectorList)
fn visit_mut_selector_list(&mut self, n: &mut SelectorList)
§fn visit_mut_sequence_of_custom_idents(
&mut self,
n: &mut SequenceOfCustomIdents
)
fn visit_mut_sequence_of_custom_idents( &mut self, n: &mut SequenceOfCustomIdents )
§fn visit_mut_simple_block(&mut self, n: &mut SimpleBlock)
fn visit_mut_simple_block(&mut self, n: &mut SimpleBlock)
§fn visit_mut_size_feature(&mut self, n: &mut SizeFeature)
fn visit_mut_size_feature(&mut self, n: &mut SizeFeature)
§fn visit_mut_size_feature_boolean(&mut self, n: &mut SizeFeatureBoolean)
fn visit_mut_size_feature_boolean(&mut self, n: &mut SizeFeatureBoolean)
§fn visit_mut_size_feature_name(&mut self, n: &mut SizeFeatureName)
fn visit_mut_size_feature_name(&mut self, n: &mut SizeFeatureName)
§fn visit_mut_size_feature_plain(&mut self, n: &mut SizeFeaturePlain)
fn visit_mut_size_feature_plain(&mut self, n: &mut SizeFeaturePlain)
§fn visit_mut_size_feature_range(&mut self, n: &mut SizeFeatureRange)
fn visit_mut_size_feature_range(&mut self, n: &mut SizeFeatureRange)
§fn visit_mut_size_feature_range_comparison(
&mut self,
n: &mut SizeFeatureRangeComparison
)
fn visit_mut_size_feature_range_comparison( &mut self, n: &mut SizeFeatureRangeComparison )
§fn visit_mut_size_feature_range_interval(
&mut self,
n: &mut SizeFeatureRangeInterval
)
fn visit_mut_size_feature_range_interval( &mut self, n: &mut SizeFeatureRangeInterval )
§fn visit_mut_size_feature_value(&mut self, n: &mut SizeFeatureValue)
fn visit_mut_size_feature_value(&mut self, n: &mut SizeFeatureValue)
fn visit_mut_span(&mut self, n: &mut Span)
§fn visit_mut_str(&mut self, n: &mut Str)
fn visit_mut_str(&mut self, n: &mut Str)
§fn visit_mut_style_block(&mut self, n: &mut StyleBlock)
fn visit_mut_style_block(&mut self, n: &mut StyleBlock)
§fn visit_mut_stylesheet(&mut self, n: &mut Stylesheet)
fn visit_mut_stylesheet(&mut self, n: &mut Stylesheet)
§fn visit_mut_subclass_selector(&mut self, n: &mut SubclassSelector)
fn visit_mut_subclass_selector(&mut self, n: &mut SubclassSelector)
fn visit_mut_subclass_selectors(&mut self, n: &mut Vec<SubclassSelector>)
§fn visit_mut_supports_and(&mut self, n: &mut SupportsAnd)
fn visit_mut_supports_and(&mut self, n: &mut SupportsAnd)
§fn visit_mut_supports_condition(&mut self, n: &mut SupportsCondition)
fn visit_mut_supports_condition(&mut self, n: &mut SupportsCondition)
§fn visit_mut_supports_condition_type(&mut self, n: &mut SupportsConditionType)
fn visit_mut_supports_condition_type(&mut self, n: &mut SupportsConditionType)
fn visit_mut_supports_condition_types( &mut self, n: &mut Vec<SupportsConditionType> )
§fn visit_mut_supports_feature(&mut self, n: &mut SupportsFeature)
fn visit_mut_supports_feature(&mut self, n: &mut SupportsFeature)
§fn visit_mut_supports_in_parens(&mut self, n: &mut SupportsInParens)
fn visit_mut_supports_in_parens(&mut self, n: &mut SupportsInParens)
§fn visit_mut_supports_not(&mut self, n: &mut SupportsNot)
fn visit_mut_supports_not(&mut self, n: &mut SupportsNot)
§fn visit_mut_supports_or(&mut self, n: &mut SupportsOr)
fn visit_mut_supports_or(&mut self, n: &mut SupportsOr)
§fn visit_mut_tag_name_selector(&mut self, n: &mut TagNameSelector)
fn visit_mut_tag_name_selector(&mut self, n: &mut TagNameSelector)
§fn visit_mut_time(&mut self, n: &mut Time)
fn visit_mut_time(&mut self, n: &mut Time)
§fn visit_mut_time_percentage(&mut self, n: &mut TimePercentage)
fn visit_mut_time_percentage(&mut self, n: &mut TimePercentage)
fn visit_mut_token(&mut self, n: &mut Token)
§fn visit_mut_token_and_span(&mut self, n: &mut TokenAndSpan)
fn visit_mut_token_and_span(&mut self, n: &mut TokenAndSpan)
§fn visit_mut_type_selector(&mut self, n: &mut TypeSelector)
fn visit_mut_type_selector(&mut self, n: &mut TypeSelector)
§fn visit_mut_unicode_range(&mut self, n: &mut UnicodeRange)
fn visit_mut_unicode_range(&mut self, n: &mut UnicodeRange)
§fn visit_mut_universal_selector(&mut self, n: &mut UniversalSelector)
fn visit_mut_universal_selector(&mut self, n: &mut UniversalSelector)
§fn visit_mut_unknown_dimension(&mut self, n: &mut UnknownDimension)
fn visit_mut_unknown_dimension(&mut self, n: &mut UnknownDimension)
§fn visit_mut_url(&mut self, n: &mut Url)
fn visit_mut_url(&mut self, n: &mut Url)
§fn visit_mut_url_modifier(&mut self, n: &mut UrlModifier)
fn visit_mut_url_modifier(&mut self, n: &mut UrlModifier)
fn visit_mut_url_modifiers(&mut self, n: &mut Vec<UrlModifier>)
§fn visit_mut_url_value(&mut self, n: &mut UrlValue)
fn visit_mut_url_value(&mut self, n: &mut UrlValue)
§fn visit_mut_url_value_raw(&mut self, n: &mut UrlValueRaw)
fn visit_mut_url_value_raw(&mut self, n: &mut UrlValueRaw)
§fn visit_mut_wq_name(&mut self, n: &mut WqName)
fn visit_mut_wq_name(&mut self, n: &mut WqName)
source§impl<L, R> Write for Either<L, R>
impl<L, R> Write for Either<L, R>
Either<L, R>
implements Write
if both L
and R
do.
Requires crate feature "use_std"
source§fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
source§fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
source§fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
source§fn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
source§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)impl<L, R> Copy for Either<L, R>
impl<L, R> Eq for Either<L, R>
impl<L, R> FusedIterator for Either<L, R>
impl<L, R> StructuralPartialEq for Either<L, R>
Auto Trait Implementations§
impl<L, R> Freeze for Either<L, R>
impl<L, R> RefUnwindSafe for Either<L, R>where
L: RefUnwindSafe,
R: RefUnwindSafe,
impl<L, R> Send for Either<L, R>
impl<L, R> Sync for Either<L, R>
impl<L, R> Unpin for Either<L, R>
impl<L, R> UnwindSafe for Either<L, R>where
L: UnwindSafe,
R: UnwindSafe,
Blanket Implementations§
§impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
§type ArchivedMetadata = ()
type ArchivedMetadata = ()
§fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata ) -> <T as Pointee>::Metadata
§impl<A, T> AsBits<T> for A
impl<A, T> AsBits<T> for A
§impl<A, T> AsMutBits<T> for A
impl<A, T> AsMutBits<T> for A
§fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘwhere
O: BitOrder,
fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘwhere
O: BitOrder,
self
as a mutable bit-slice region with the O
ordering.§fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>where
O: BitOrder,
fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>where
O: BitOrder,
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> CallHasher for T
impl<T> CallHasher for T
§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<T> Conv for T
impl<T> Conv for T
§impl<F, W, T, D> Deserialize<With<T, W>, D> for F
impl<F, W, T, D> Deserialize<With<T, W>, D> for F
§fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize( &self, deserializer: &mut D ) -> Result<With<T, W>, <D as Fallible>::Error>
source§impl<N, E, I> ElementIterator<N, E> for I
impl<N, E, I> ElementIterator<N, E> for I
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<It> IdentifyLast for Itwhere
It: Iterator,
impl<It> IdentifyLast for Itwhere
It: Iterator,
fn identify_last(self) -> Iter<It> ⓘ
source§impl<T> ImplicitClone for Twhere
T: Clone,
impl<T> ImplicitClone for Twhere
T: Clone,
source§fn clone_quote_var(&self) -> Self
fn clone_quote_var(&self) -> Self
ecma_quote
only.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
§type IntoFuture = F
type IntoFuture = F
source§fn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
§impl<T> IntoParallelIterator for Twhere
T: ParallelIterator,
impl<T> IntoParallelIterator for Twhere
T: ParallelIterator,
§impl<I> IteratorExt for Iwhere
I: Iterator,
impl<I> IteratorExt for Iwhere
I: Iterator,
§fn chain_with<F, I>(
self,
f: F
) -> ChainWith<Self, F, <I as IntoIterator>::IntoIter>
fn chain_with<F, I>( self, f: F ) -> ChainWith<Self, F, <I as IntoIterator>::IntoIter>
source§impl<T> Itertools for T
impl<T> Itertools for T
source§fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>
fn interleave<J>( self, other: J ) -> Interleave<Self, <J as IntoIterator>::IntoIter>
source§fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>
fn interleave_shortest<J>( self, other: J ) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>
source§fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>
fn intersperse( self, element: Self::Item ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>
source§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>
source§fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn batching<B, F>(self, f: F) -> Batching<Self, F>
fn batching<B, F>(self, f: F) -> Batching<Self, F>
source§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
source§fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
source§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>
source§fn tuples<T>(self) -> Tuples<Self, T>
fn tuples<T>(self) -> Tuples<Self, T>
source§fn tee(self) -> (Tee<Self>, Tee<Self>)
fn tee(self) -> (Tee<Self>, Tee<Self>)
source§fn step(self, n: usize) -> Step<Self>where
Self: Sized,
fn step(self, n: usize) -> Step<Self>where
Self: Sized,
n
elements in the base iterator
for each iteration. Read moresource§fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_results<F, T, U, E>( self, f: F ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
.map_ok()
.source§fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
Result::Ok
value. Result::Err
values are
unchanged. Read moresource§fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>
Result::Ok
value with the provided closure. Result::Err
values are
unchanged. Read moresource§fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>
Result::Ok
value with the provided closure. Result::Err
values are unchanged. Read moresource§fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>
Result::Ok
value into
a series of Result::Ok
values. Result::Err
values are unchanged. Read moresource§fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>
fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>
Result
values instead. Read moresource§fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>
fn merge<J>( self, other: J ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>
source§fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>
fn merge_by<J, F>( self, other: J, is_first: F ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>
source§fn merge_join_by<J, F, T>(
self,
other: J,
cmp_fn: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeFuncLR<F, <F as FuncLR<Self::Item, <<J as IntoIterator>::IntoIter as Iterator>::Item>>::T>>
fn merge_join_by<J, F, T>( self, other: J, cmp_fn: F ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeFuncLR<F, <F as FuncLR<Self::Item, <<J as IntoIterator>::IntoIter as Iterator>::Item>>::T>>
source§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>
source§fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
source§fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>
fn cartesian_product<J>( self, other: J ) -> Product<Self, <J as IntoIterator>::IntoIter>
self
and J
. Read moresource§fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
self
. Read moresource§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>
source§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>
source§fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>
fn dedup_by<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>
source§fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
source§fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>
fn dedup_by_with_count<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>
source§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
source§fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
source§fn unique(self) -> Unique<Self>
fn unique(self) -> Unique<Self>
source§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>
source§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>
accept
returns true
. Read moresource§fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>
Clone
-able iterator
to only pick off elements while the predicate accept
returns true
. Read moresource§fn take_while_inclusive<F>(self, accept: F) -> TakeWhileInclusive<Self, F>
fn take_while_inclusive<F>(self, accept: F) -> TakeWhileInclusive<Self, F>
true
, including the element for which the predicate
first returned false
. Read moresource§fn while_some<A>(self) -> WhileSome<Self>
fn while_some<A>(self) -> WhileSome<Self>
Option<A>
iterator elements
and produces A
. Stops on the first None
encountered. Read moresource§fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>
source§fn combinations(self, k: usize) -> Combinations<Self>
fn combinations(self, k: usize) -> Combinations<Self>
k
-length combinations of
the elements from an iterator. Read moresource§fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>
fn combinations_with_replacement( self, k: usize ) -> CombinationsWithReplacement<Self>
k
-length combinations of
the elements from an iterator, with replacement. Read moresource§fn permutations(self, k: usize) -> Permutations<Self>
fn permutations(self, k: usize) -> Permutations<Self>
source§fn powerset(self) -> Powerset<Self>
fn powerset(self) -> Powerset<Self>
source§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>
min
by filling missing elements using a closure f
. Read moresource§fn with_position(self) -> WithPosition<Self>where
Self: Sized,
fn with_position(self) -> WithPosition<Self>where
Self: Sized,
Position
to
ease special-case handling of the first or last elements. Read moresource§fn positions<P>(self, predicate: P) -> Positions<Self, P>
fn positions<P>(self, predicate: P) -> Positions<Self, P>
source§fn update<F>(self, updater: F) -> Update<Self, F>
fn update<F>(self, updater: F) -> Update<Self, F>
source§fn next_tuple<T>(&mut self) -> Option<T>
fn next_tuple<T>(&mut self) -> Option<T>
source§fn collect_tuple<T>(self) -> Option<T>
fn collect_tuple<T>(self) -> Option<T>
source§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
source§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
source§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
source§fn contains<Q>(&mut self, query: &Q) -> bool
fn contains<Q>(&mut self, query: &Q) -> bool
true
if the given item is present in this iterator. Read moresource§fn all_equal_value(
&mut self
) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>
fn all_equal_value( &mut self ) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>
source§fn all_unique(&mut self) -> bool
fn all_unique(&mut self) -> bool
source§fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn foreach<F>(self, f: F)
fn foreach<F>(self, f: F)
f
eagerly on each element of the iterator. Read moresource§fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
.collect_vec()
is simply a type specialization of Iterator::collect
,
for convenience.source§fn try_collect<T, U, E>(self) -> Result<U, E>
fn try_collect<T, U, E>(self) -> Result<U, E>
source§fn set_from<'a, A, J>(&mut self, from: J) -> usize
fn set_from<'a, A, J>(&mut self, from: J) -> usize
self
from the from
iterator,
stopping at the shortest of the two iterators. Read moresource§fn join(&mut self, sep: &str) -> String
fn join(&mut self, sep: &str) -> String
sep
. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
sep
. Read moresource§fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
sep
. Read moresource§fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
.fold_ok()
.source§fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
Result
values from an iterator. Read moresource§fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
Option
values from an iterator. Read moresource§fn fold1<F>(self, f: F) -> Option<Self::Item>
fn fold1<F>(self, f: F) -> Option<Self::Item>
Iterator::reduce
insteadsource§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
source§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
source§fn sum1<S>(self) -> Option<S>
fn sum1<S>(self) -> Option<S>
source§fn product1<P>(self) -> Option<P>
fn product1<P>(self) -> Option<P>
source§fn sorted_unstable(self) -> IntoIter<Self::Item>
fn sorted_unstable(self) -> IntoIter<Self::Item>
source§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item>
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item>
source§fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>
source§fn sorted(self) -> IntoIter<Self::Item>
fn sorted(self) -> IntoIter<Self::Item>
source§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>
source§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>
source§fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item>
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item>
source§fn k_smallest(self, k: usize) -> IntoIter<Self::Item>
fn k_smallest(self, k: usize) -> IntoIter<Self::Item>
source§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
Iterator::partition
, each partition may
have a distinct type. Read moresource§fn partition_result<A, B, T, E>(self) -> (A, B)
fn partition_result<A, B, T, E>(self) -> (A, B)
Result
s into one list of all the Ok
elements
and another list of all the Err
elements. Read moresource§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
HashMap
of keys mapped to Vec
s of values. Keys and values
are taken from (Key, Value)
tuple pairs yielded by the input iterator. Read moresource§fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
Iterator
on a HashMap
. Keys mapped to Vec
s of values. The key is specified
in the closure. Read moresource§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>>
fn into_grouping_map_by<K, V, F>( self, key_mapper: F ) -> GroupingMap<MapForGrouping<Self, F>>
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
source§fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
source§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
source§fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
source§fn minmax(self) -> MinMaxResult<Self::Item>
fn minmax(self) -> MinMaxResult<Self::Item>
source§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
source§fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
source§fn position_max(self) -> Option<usize>
fn position_max(self) -> Option<usize>
source§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
source§fn position_max_by<F>(self, compare: F) -> Option<usize>
fn position_max_by<F>(self, compare: F) -> Option<usize>
source§fn position_min(self) -> Option<usize>
fn position_min(self) -> Option<usize>
source§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
source§fn position_min_by<F>(self, compare: F) -> Option<usize>
fn position_min_by<F>(self, compare: F) -> Option<usize>
source§fn position_minmax(self) -> MinMaxResult<usize>
fn position_minmax(self) -> MinMaxResult<usize>
source§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
source§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
source§fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
source§fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
source§fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
.next()
values without advancing the base iterator. Read moresource§fn counts(self) -> HashMap<Self::Item, usize>
fn counts(self) -> HashMap<Self::Item, usize>
HashMap
which
contains each item that appears in the iterator and the number
of times it appears. Read moresource§fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
HashMap
which
contains each item that appears in the iterator and the number
of times it appears,
determining identity using a keying function. Read moresource§fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
§impl<T> LayoutRaw for T
impl<T> LayoutRaw for T
§fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>
fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>
source§impl<IT> MultiUnzip<()> for IT
impl<IT> MultiUnzip<()> for IT
source§fn multiunzip(self)
fn multiunzip(self)
source§impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
source§fn multiunzip(self) -> (FromA,)
fn multiunzip(self) -> (FromA,)
source§impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
source§fn multiunzip(self) -> (FromA, FromB)
fn multiunzip(self) -> (FromA, FromB)
source§impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC)
fn multiunzip(self) -> (FromA, FromB, FromC)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
source§fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
source§fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
source§fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
source§fn multiunzip(
self
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
fn multiunzip( self ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
§impl<D> OwoColorize for D
impl<D> OwoColorize for D
§fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
§fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
§fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
§fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
§fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
§fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
§fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
§fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
§fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
§fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
§fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
§fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
§fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
§fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
§fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
§fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
§fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
§fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
§fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
§fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
§fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
§fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
§fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
§fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
§fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
§fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
§fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
§fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
§fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::fg
or
a color-specific method, such as OwoColorize::green
, Read more§fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::bg
or
a color-specific method, such as OwoColorize::on_yellow
, Read more§fn fg_rgb<const R: u8, const G: u8, const B: u8>(
&self
) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>
fn fg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>
§fn bg_rgb<const R: u8, const G: u8, const B: u8>(
&self
) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>
fn bg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>
§fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>
fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>
§fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>
fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> SpanExt for Twhere
T: Spanned,
impl<T> SpanExt for Twhere
T: Spanned,
fn is_synthesized(&self) -> bool
fn starts_on_new_line(&self, format: ListFormat) -> bool
§fn comment_range(&self) -> Span
fn comment_range(&self) -> Span
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.source§impl<T> ToHex for T
impl<T> ToHex for T
source§fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
self
into the result. Lower case
letters are used (e.g. f9b4ca
)source§fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
self
into the result. Upper case
letters are used (e.g. F9B4CA
)