# [−] [src] Enum regex_syntax::hir::HirKind

    pub enum HirKind {
        Empty,
        Literal(Literal),
        Class(Class),
        Anchor(Anchor),
        WordBoundary(WordBoundary),
        Repetition(Repetition),
        Group(Group),
        Concat(Vec<Hir>),
        Alternation(Vec<Hir>),
    }

The kind of an arbitrary `Hir` expression.

## Variants

`Empty`

The empty regular expression, which matches everything, including the empty string.

`Literal(Literal)`

A single literal character that matches exactly this character.

`Class(Class)`

A single character class that matches any of the characters in the class. A class can either consist of Unicode scalar values as characters, or it can use bytes.

`Anchor(Anchor)`

An anchor assertion. An anchor assertion match always has zero length.

`WordBoundary(WordBoundary)`

A word boundary assertion, which may or may not be Unicode aware. A word boundary assertion match always has zero length.

`Repetition(Repetition)`

A repetition operation applied to a child expression.

`Group(Group)`

A possibly capturing group, which contains a child expression.

`Concat(Vec<Hir>)`

A concatenation of expressions. A concatenation always has at least two child expressions.

A concatenation matches only if each of its child expression matches one after the other.

`Alternation(Vec<Hir>)`

An alternation of expressions. An alternation always has at least two child expressions.

An alternation matches only if at least one of its child expression matches. If multiple expressions match, then the leftmost is preferred.

## Methods

### `impl HirKind` [src]

#### `pub fn is_empty(&self) -> bool` [src]

Return true if and only if this HIR is the empty regular expression.

Note that this is not defined inductively. That is, it only tests if this kind is the `Empty` variant. To get the inductive definition, use the `is_match_empty` method on `Hir`.

#### `pub fn has_subexprs(&self) -> bool` [src]

Returns true if and only if this kind has any (including possibly empty) subexpressions.

## Trait Implementations

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

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

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

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

This method tests for `!=`.

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

#### `fn clone(&self) -> HirKind` [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 HirKind` [src]

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

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

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl Send for HirKind`

### `impl Sync for HirKind`

## 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`)