Possessive Quantifiers Revisited

Possessive vs atomic — the same idea

Possessive quantifiers (*+, ++, ?+, {n,m}+) and atomic groups achieve the same thing — disable backtracking — through different syntax.

a++ is equivalent to (?>a+). Both refuse to give back characters once consumed.

When to use which

Possessive: when you're applying the no-backtrack rule to a single quantifier. \d++, \w*+.

Atomic group: when you're wrapping a multi-element pattern and want to lock the whole thing. (?>\d{3}-\d{4}) wouldn't backtrack into a different split of dashes and digits.

Engine support comparison

Engine	Atomic	Possessive
Python `re` 3.11+	✓	✓
Python `regex`	✓	✓
PCRE / PHP	✓	✓
Java	✓	✓
Ruby	✓	✓ (1.9+)
.NET	✓	✗
JavaScript	✗	✗
RE2/Go	—	—

The portable workaround

If your engine has neither (notably JavaScript), the workaround is to refactor the pattern to not need backtracking. Use negated character classes ([^X]+ instead of .+?X) or anchored alternation. Often makes the pattern faster AND more readable.

Code

Possessive equivalents·python

import sys
import re

if sys.version_info >= (3, 11):
    # Possessive
    re.search(r'\d++X', 'aaa')   # fails fast — \d won't match anyway

    # Atomic equivalent
    re.search(r'(?>\d+)X', 'aaa')

    # Both protect against backtracking explosion
    # re.search(r'\d+X', '9'*30 + 'Y')  # slower due to backtracking
    # re.search(r'\d++X', '9'*30 + 'Y')  # immediate fail

# Portable workaround: negated character class instead of .+?
# Bad (greedy with backtrack)
re.search(r'".*?"', '"hello" world')

# Better (no backtrack possible)
re.search(r'"[^"]*"', '"hello" world')

# This works in EVERY engine, including JavaScript and RE2

Possessive Quantifiers Revisited

Possessive vs atomic — the same idea

When to use which

Engine support comparison

The portable workaround

Code

External links

Exercise

Progress

Comments 0