Rename Re to RegexEngine

Author: sminez

src/lib.rs

@@ -18,7 +18,7 @@ pub enum Error {
     /// A syntax error in the provided structural regular expression.
     Syntax(ParseError),
     /// An error that occurred during parsing or compiling a regular expression with the given
-    /// [Re][re::Re] implementation.
+    /// [RegexEngine][re::RegexEngine].
     Regex(Box<dyn error::Error>),
 }
 

src/re.rs

@@ -1,17 +1,18 @@
 //! The required interface for an underlying regex engine
-use std::{fmt, io};
+use std::{fmt, io, ops::Range};
 
-/// An [Re] is an underlying regular expression engine that can be used to match and extract text
-/// as part of a structural regular expression.
+/// A [RegexEngine] is an underlying regular expression engine that can be used to match and
+/// extract text as part of a structural regular expression.
 ///
 /// The interface provided by this trait is intended for use by [Structex][crate::Structex] as an
 /// internal implementation detail and is likely not particularly useful outside of this crate.
 /// Implementors of this trait should pay particular attention to the requirements around
 /// compilation in order for the resulting regex expressions to be compatible with this crate.
-pub trait Re: Sized {
-    /// Error type that is returned by the [Re::compile] method when compilation of a given regular
-    /// expression fails. This will be wrapped into an [Error][crate::Error] when returned from
-    /// [Structex::compile][crate::Structex::new] or [StructexBuilder::build][crate::StructexBuilder::build].
+pub trait RegexEngine: Sized {
+    /// Error type that is returned by the [RegexEngine::compile] method when compilation of a
+    /// given regular expression fails. This will be wrapped into an [Error][crate::Error] when
+    /// returned from [Structex::compile][crate::Structex::new] or
+    /// [StructexBuilder::build][crate::StructexBuilder::build].
     type CompileError: std::error::Error + 'static;
 
     /// Attempt to compile the given regular expression for use inside of a [Structex][crate::Structex].
@@ -30,13 +31,13 @@ pub trait Re: Sized {
     fn compile(re: &str) -> Result<Self, Self::CompileError>;
 }
 
-/// A haystack that can be searched by an [Re] regular expression engine.
+/// A haystack that can be searched by a [RegexEngine].
 ///
 /// Typically this is a [&str] but some engines may support richer types in order to provide
 /// searching of streams or discontiguous inputs.
 pub trait Haystack<R>: Sliceable
 where
-    R: Re,
+    R: RegexEngine,
 {
     /// Returns true if there is a match for the regex between the given byte offsets in the haystack.
     ///
@@ -60,16 +61,14 @@ pub trait Sliceable: Writable + fmt::Debug + PartialEq + Eq + Copy {
     where
         Self: 'h;
 
-    /// A contiguous sub-section between the given bytes offsets.
-    ///
-    /// The given byte offsets from a half-open interval, inclusive of `from` but omitting `to`.
-    /// This is the same semantics as a normal Rust range `from..to`.
-    fn slice<'h>(&'h self, from: usize, to: usize) -> Self::Slice<'h>;
+    /// The contiguous sub-section of self that is denoted by the given byte [Range].
+    fn slice<'h>(&'h self, range: Range<usize>) -> Self::Slice<'h>;
 
     /// The maximum length in bytes.
     ///
     /// This value will be used as the upper bound to extract slices when searching for matches. As
-    /// such, this value must be a valid `to` argument to the [slice][Sliceable::slice] method.
+    /// such, this value must be a valid end to the `range` argument to the
+    /// [slice][Sliceable::slice] method.
     fn max_len(&self) -> usize;
 }
 
@@ -87,8 +86,8 @@ impl Sliceable for &str {
     where
         Self: 'h;
 
-    fn slice(&self, from: usize, to: usize) -> &str {
-        &self[from..to]
+    fn slice(&self, range: Range<usize>) -> &str {
+        &self[range]
     }
 
     fn max_len(&self) -> usize {
@@ -111,8 +110,8 @@ impl Sliceable for &[u8] {
     where
         Self: 'h;
 
-    fn slice(&self, from: usize, to: usize) -> &[u8] {
-        &self[from..to]
+    fn slice(&self, range: Range<usize>) -> &[u8] {
+        &self[range]
     }
 
     fn max_len(&self) -> usize {
@@ -129,8 +128,8 @@ impl Writable for &[u8] {
     }
 }
 
-/// Represents the capture group positions for a single [Re] match only in terms of byte offsets
-/// into the original haystack.
+/// Represents the capture group positions for a single [RegexEngine] match only in terms of byte
+/// offsets into the original haystack.
 ///
 /// This is converted into a [Captures] by [TaggedCapturesIter][crate::TaggedCapturesIter] as
 /// matches are returned during iteration.
@@ -165,8 +164,8 @@ impl RawCaptures {
     }
 }
 
-/// Represents the capture group positions for a single [Re] match in terms of byte offsets into
-/// the original haystack that the match was run against.
+/// Represents the capture group positions for a single [RegexEngine] match in terms of byte
+/// offsets into the original haystack that the match was run against.
 #[derive(Debug, PartialEq, Eq)]
 pub struct Captures<H>
 where
@@ -224,21 +223,21 @@ where
     pub fn match_text(&self) -> H::Slice<'_> {
         let (from, to) = self.get_match();
 
-        self.haystack.slice(from, to)
+        self.haystack.slice(from..to)
     }
 
     /// The full text of the submatch, if present, in the original haystack.
     pub fn submatch_text(&self, n: usize) -> Option<H::Slice<'_>> {
         let (from, to) = self.get(n)?;
 
-        Some(self.haystack.slice(from, to))
+        Some(self.haystack.slice(from..to))
     }
 
     /// Iterate over all submatches starting with the full match.
     pub fn iter_submatches(&self) -> impl Iterator<Item = Option<H::Slice<'_>>> {
         self.caps
             .iter()
-            .map(|cap| cap.map(|(from, to)| self.haystack.slice(from, to)))
+            .map(|cap| cap.map(|(from, to)| self.haystack.slice(from..to)))
     }
 }
 
@@ -247,7 +246,7 @@ mod impl_for_regex {
     use super::*;
     use regex::{Error, Regex, RegexBuilder};
 
-    impl Re for Regex {
+    impl RegexEngine for Regex {
         type CompileError = Error;
 
         fn compile(re: &str) -> Result<Self, Self::CompileError> {

src/se/extract.rs

@@ -1,6 +1,6 @@
 use crate::{
     compile::Inst,
-    re::{Haystack, RawCaptures, Re},
+    re::{Haystack, RawCaptures, RegexEngine},
     se::{Dot, Inner, MatchesInner, TaggedCaptures},
 };
 use std::sync::Arc;
@@ -45,7 +45,7 @@ impl Extract {
 
 pub(super) struct Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     haystack: H,
@@ -63,7 +63,7 @@ where
 
 impl<'s, R, H> Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     pub fn new(haystack: H, parent: Dot, ext: &'s Extract, inner: Arc<Inner<R>>) -> Self {
@@ -100,7 +100,7 @@ where
 
 impl<'s, R, H> Iterator for Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     type Item = TaggedCaptures<H>;

src/se/guard.rs

@@ -1,6 +1,6 @@
 use crate::{
     compile::Inst,
-    re::{Haystack, Re},
+    re::{Haystack, RegexEngine},
     se::{Dot, Inner, MatchesInner},
 };
 use std::sync::Arc;
@@ -49,7 +49,7 @@ impl Guard {
         inner: Arc<Inner<R>>,
     ) -> Option<MatchesInner<'s, R, H>>
     where
-        R: Re,
+        R: RegexEngine,
         H: Haystack<R>,
     {
         let (from, to) = dot.loc();

src/se/mod.rs

@@ -3,7 +3,7 @@
 use crate::{
     Error,
     compile::{Compiler, Inst},
-    re::{Captures, Haystack, RawCaptures, Re, Sliceable},
+    re::{Captures, Haystack, RawCaptures, RegexEngine, Sliceable},
 };
 use std::{fmt, ops::Deref, sync::Arc};
 
@@ -25,15 +25,15 @@ pub(crate) use narrow::Narrow;
 #[derive(Clone)]
 pub struct Structex<R>
 where
-    R: Re,
+    R: RegexEngine,
 {
     raw: Arc<str>,
     inner: Arc<Inner<R>>,
 }
 
 impl<R> fmt::Debug for Structex<R>
 where
-    R: Re,
+    R: RegexEngine,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Structex").field(&self.raw).finish()
@@ -42,7 +42,7 @@ where
 
 impl<R> fmt::Display for Structex<R>
 where
-    R: Re,
+    R: RegexEngine,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Structex({})", self.raw)
@@ -51,7 +51,7 @@ where
 
 impl<R> Structex<R>
 where
-    R: Re,
+    R: RegexEngine,
 {
     /// Compiles a structural regular expression. Once compiled it may be used repeatedly and cloned
     /// cheaply, but note that compilation can be an expensive process so [Structex] instances
@@ -379,7 +379,7 @@ impl StructexBuilder {
     /// If the expression was invalid, an error is returned.
     pub fn build<R>(self) -> Result<Structex<R>, Error>
     where
-        R: Re,
+        R: RegexEngine,
     {
         let mut c = Compiler {
             require_actions: self.require_actions,
@@ -422,7 +422,7 @@ impl StructexBuilder {
 
 pub(super) struct Inner<R>
 where
-    R: Re,
+    R: RegexEngine,
 {
     pub(super) inst: Inst,
     pub(super) re: Vec<R>,
@@ -564,15 +564,15 @@ impl Action {
 /// This iterator is created by [Structex::iter_tagged_captures].
 pub struct TaggedCapturesIter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     inner: Option<MatchesInner<'s, R, H>>,
 }
 
 impl<'s, R, H> TaggedCapturesIter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     fn new(inst: &'s Inst, inner: Arc<Inner<R>>, haystack: H) -> Self {
@@ -592,7 +592,7 @@ where
 
 impl<'s, R, H> Iterator for TaggedCapturesIter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     type Item = TaggedCaptures<H>;
@@ -604,7 +604,7 @@ where
 
 enum MatchesInner<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     Extract(extract::Iter<'s, R, H>),
@@ -614,7 +614,7 @@ where
 
 impl<'s, R, H> MatchesInner<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     fn new(inst: &'s Inst, inner: Arc<Inner<R>>, haystack: H, dot: Dot) -> Option<Self> {
@@ -646,7 +646,7 @@ where
 
 impl<'s, R, H> Iterator for MatchesInner<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     type Item = TaggedCaptures<H>;

src/se/narrow.rs

@@ -1,6 +1,6 @@
 use crate::{
     compile::Inst,
-    re::{Haystack, Re},
+    re::{Haystack, RegexEngine},
     se::{Dot, Inner, MatchesInner},
 };
 use std::sync::Arc;
@@ -19,7 +19,7 @@ impl Narrow {
         inner: Arc<Inner<R>>,
     ) -> Option<MatchesInner<'s, R, H>>
     where
-        R: Re,
+        R: RegexEngine,
         H: Haystack<R>,
     {
         let (from, to) = dot.loc();

src/se/parallel.rs

@@ -1,21 +1,21 @@
 use crate::{
     compile::Inst,
-    re::{Haystack, Re},
+    re::{Haystack, RegexEngine},
     se::{Dot, Inner, MatchesInner, TaggedCaptures},
 };
 use std::sync::Arc;
 
 pub(super) struct Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     branches: Vec<Branch<'s, R, H>>,
 }
 
 impl<'s, R, H> Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     pub fn new(haystack: H, dot: Dot, branches: &'s [Inst], inner: Arc<Inner<R>>) -> Self {
@@ -33,7 +33,7 @@ where
 
 impl<'s, R, H> Iterator for Iter<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     type Item = TaggedCaptures<H>;
@@ -67,7 +67,7 @@ where
 
 struct Branch<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     held: Option<TaggedCaptures<H>>,
@@ -76,7 +76,7 @@ where
 
 impl<'s, R, H> Branch<'s, R, H>
 where
-    R: Re,
+    R: RegexEngine,
     H: Haystack<R>,
 {
     fn get_match(&self) -> Option<(usize, usize)> {