# [−] [src] Struct regex_syntax::hir::print::Printer

    pub struct Printer { /* fields omitted */ }

A printer for a regular expression's high-level intermediate representation.

A printer converts a high-level intermediate representation (HIR) to a regular expression pattern string. This particular printer uses constant stack space and heap space proportional to the size of the HIR.

Since this printer is only using the HIR, the pattern it prints will likely not resemble the original pattern at all. For example, a pattern like `\pL` will have its entire class written out.

The purpose of this printer is to provide a means to mutate an HIR and then build a regular expression from the result of that mutation. (A regex library could provide a constructor from this HIR explicitly, but that creates an unnecessary public coupling between the regex library and this specific HIR representation.)

## Methods

### `impl Printer` [src]

#### `pub fn new() -> Printer` [src]

Create a new printer.

#### `pub fn print<W: Write>(&mut self, hir: &Hir, wtr: W) -> Result` [src]

Print the given `Ast` to the given writer. The writer must implement `fmt::Write`. Typical implementations of `fmt::Write` that can be used here are a `fmt::Formatter` (which is available in `fmt::Display` implementations) or a `&mut String`.

## Trait Implementations

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

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

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl Send for Printer`

### `impl Sync for Printer`

## Blanket Implementations

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

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

Performs the conversion.

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