# [−] [src] Struct regex_syntax::hir::ClassUnicode

    pub struct ClassUnicode { /* fields omitted */ }

A set of characters represented by Unicode scalar values.

## Methods

### `impl ClassUnicode` [src]

#### `pub fn new<I>(ranges: I) -> ClassUnicode where
I: IntoIterator<Item = ClassUnicodeRange>,` [src]

Create a new class from a sequence of ranges.

The given ranges do not need to be in any specific order, and ranges may overlap.

#### `pub fn empty() -> ClassUnicode` [src]

Create a new class with no ranges.

#### `pub fn push(&mut self, range: ClassUnicodeRange)` [src]

Add a new range to this set.

####
ⓘImportant traits for ClassUnicodeIter<'a>

### Important traits for ClassUnicodeIter<'a>

`impl<'a> Iterator for ClassUnicodeIter<'a> type Item = &'a ClassUnicodeRange;`
`pub fn iter(&self) -> ClassUnicodeIter` [src]

Return an iterator over all ranges in this class.

The iterator yields ranges in ascending order.

#### `pub fn ranges(&self) -> &[ClassUnicodeRange]` [src]

Return the underlying ranges as a slice.

#### `pub fn case_fold_simple(&mut self)` [src]

Expand this character class such that it contains all case folded characters, according to Unicode's "simple" mapping. For example, if this class consists of the range `a-z`, then applying case folding will result in the class containing both the ranges `a-z` and `A-Z`.

#### `pub fn negate(&mut self)` [src]

Negate this character class.

For all `c` where `c` is a Unicode scalar value, if `c` was in this set, then it will not be in this set after negation.

#### `pub fn union(&mut self, other: &ClassUnicode)` [src]

Union this character class with the given character class, in place.

#### `pub fn intersect(&mut self, other: &ClassUnicode)` [src]

Intersect this character class with the given character class, in place.

#### `pub fn difference(&mut self, other: &ClassUnicode)` [src]

Subtract the given character class from this character class, in place.

#### `pub fn symmetric_difference(&mut self, other: &ClassUnicode)` [src]

Compute the symmetric difference of the given character classes, in place.

This computes the symmetric difference of two character classes. This removes all elements in this class that are also in the given class, but all adds all elements from the given class that aren't in this class. That is, the class will contain all elements in either class, but will not contain any elements that are in both classes.

## Trait Implementations

### `impl PartialEq<ClassUnicode> for ClassUnicode` [src]

#### `fn eq(&self, other: &ClassUnicode) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &ClassUnicode) -> bool` [src]

This method tests for `!=`.

### `impl Clone for ClassUnicode` [src]

#### `fn clone(&self) -> ClassUnicode` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Eq for ClassUnicode` [src]

### `impl Debug for ClassUnicode` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl Send for ClassUnicode`

### `impl Sync for ClassUnicode`

## Blanket Implementations

### `impl<T> From<T> for T` [src]

#### `fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)` [src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)