What's the most sensible way to emulate lookbehind behavior in Rust regex?

Question

The Rust regex crate states:

This crate provides a native implementation of regular expressions that is heavily based on RE2 both in syntax and in implementation. Notably, backreferences and arbitrary lookahead/lookbehind assertions are not provided.

As of this writing, "rust regex lookbehind" comes back with no results from DuckDuckGo.

I've never had to work around this before, but I can think of two approaches:

Approach 1 (forward)

1. Iterate over .captures() for the pattern I want to use as lookbehind.
2. Match the thing I actually wanted to match between captures. (forward)

Approach 2 (reverse)

1. Match the pattern I really want to match.
2. For each match, look for the lookbehind pattern until the end byte of a previous capture or the beginning of the string.

Not only does this seem like a huge pain, it also seems like a lot of edge cases are going to trip me up. Is there a better way to go about this?

Example

Given a string like:

"Fish33-Tiger2Hyena4-"

I want to extract ["33-", "2", "4-"] iff each one follows a string like "Fish".

Answer 1

Without a motivating example, it's hard to usefully answer your question in a general way. In many cases, you can substitute lookaround operators with two regexes---one to search for candidates and another to produce the actual match you're interested in. However, this approach isn't always feasible.

If you're truly stuck, then you're only option is to use a regex library that supports these features. Rust has bindings to a couple of them:

• PCRE
• PCRE2
• Oniguruma

There is also a more experimental library, fancy-regex, which is built on top of the regex crate.