Module regex_automata::util

A collection of modules that provide APIs that are useful across many regex engines.

While one should explore the sub-modules directly to get a sense of what’s there, here are some highlights that tie the sub-modules to higher level use cases:

• alphabet contains APIs that are useful if you’re doing low level things with the DFAs in this crate. For example, implementing determinization or walking its state graph directly.
• captures contains APIs for dealing with capture group matches and their mapping to “slots” used inside an NFA graph. This is also where you can find iterators over capture group names.
• escape contains types for pretty-printing raw byte slices as strings.
• iter contains API helpers for writing regex iterators.
• lazy contains a no-std and no-alloc variant of lazy_static! and once_cell.
• look contains APIs for matching and configuring look-around assertions.
• pool provides a way to reuse mutable memory allocated in a thread safe manner.
• prefilter provides APIs for building prefilters and using them in searches.
• primitives are what you might use if you’re doing lower level work on automata, such as walking an NFA state graph.
• syntax provides some higher level convenience functions for interacting with the regex-syntax crate.
• wire is useful if you’re working with DFA serialization.

Modules

• alphabet
  This module provides APIs for dealing with the alphabets of finite state machines.
• captures
  Provides types for dealing with capturing groups.
• escape
  Provides convenience routines for escaping raw bytes.
• interpolate
  Provides routines for interpolating capture group references.
• iter
  Generic helpers for iteration of matches from a regex engine in a haystack.
• lazy
  A lazily initialized value for safe sharing between threads.
• look
  Types and routines for working with look-around assertions.
• pool
  A thread safe memory pool.
• prefilter
  Defines a prefilter for accelerating regex searches.
• primitives
  Lower level primitive types that are useful in a variety of circumstances.
• syntax
  Utilities for dealing with the syntax of a regular expression.
• wire
  Types and routines that support the wire format of finite automata.