Getting Started with RegexBuilder in Swift

Why RegexBuilder Matters

Traditional regular expressions suffer from several problems that make them error-prone and difficult to work with in large codebases. The cryptic syntax of regex patterns makes them challenging to read and understand, even for experienced developers. Typos in regex patterns often only surface at runtime, leading to delayed bug discovery. Swift's RegexBuilder addresses these pain points by providing a Swift-native way to construct regex patterns that leverage the language's type system and compile-time checking.

Key benefits of RegexBuilder:

• Compile-time validation catches errors before runtime
• Readable syntax that reads like plain English
• Type-safe captures with automatic type conversion
• Maintainable patterns that are easy to modify

Whether you're building web applications or mobile iOS apps, RegexBuilder helps you write more reliable text processing code.

Setting Up RegexBuilder

To start using RegexBuilder in your Swift project, you need to import the RegexBuilder module. This module is included with Swift 5.7 and later, so no additional dependencies are required.

import RegexBuilder

// Simple example
let greeting = Regex {
 "Hello, "
 "World"
}

For projects targeting iOS 16+, macOS 13+, or later platform versions, RegexBuilder is fully supported out of the box. Our iOS development team regularly uses RegexBuilder for form validation, data parsing, and content processing in production applications.

Core RegexBuilder Components

The Regex Type

At the heart of RegexBuilder is the Regex type, which represents a compiled regular expression. Unlike traditional regex creation through string literals, RegexBuilder uses a result builder pattern that allows you to construct regex patterns using plain Swift syntax.

Matching Literal Strings

The simplest form of pattern matching in RegexBuilder is matching literal strings. You can include any string directly within the Regex closure, and it will match that exact sequence of characters with compile-time validation.

let greeting = Regex {
 "Hello, "
 "World"
}

This approach integrates seamlessly with our software development practices, ensuring type safety across your codebase.

Character Classes and Quantifiers

Built-in Character Classes

RegexBuilder provides a rich set of built-in character classes that cover common matching scenarios:

• .digit - matches any numeric character
• .word - matches letters, digits, and underscores
• .whitespace - matches spaces, tabs, and other whitespace
• .any - matches any character

Quantifiers for Repetition

Quantifiers control how many times a pattern should match:

• OneOrMore - matches one or more occurrences
• ZeroOrMore - matches zero or more occurrences
• Optionally - makes a pattern optional
• Repeat - fine-grained control with exact counts or ranges

let numberPattern = Regex {
 OneOrMore(.digit)
}

let optionalSpace = Regex {
 Optionally(.whitespace)
}

These patterns are particularly useful when building data validation systems for user input processing.

Capture Groups and Data Extraction

Basic Captures

Capture groups extract specific portions of matched text using the Capture component:

let nameRef = Reference(Substring.self)

let namePattern = Regex {
 "Name: "
 Capture(as: nameRef) {
 OneOrMore(.word)
 }
}

if let match = text.firstMatch(of: namePattern) {
 print("Found name: \(match[nameRef])")
}

TryCapture for Type Conversion

The TryCapture component provides automatic type conversion:

let ageRef = Reference(Int.self)

let agePattern = Regex {
 "Age: "
 TryCapture(as: ageRef) {
 OneOrMore(.digit)
 } transform: { Substring in
 Int($0)
 }
}

Type-safe captures are essential for building robust mobile applications that process user data reliably.

Practical Examples

Email Validation

let emailPattern = Regex {
 OneOrMore(.characterClass(
 in: "a"..."z", "A"..."Z", "0"..."9",
 "._-%+@"
 ))
 "@"
 OneOrMore(.word)
 "."
 Repeat(2..., 63) { .letter }
}

Phone Number Parsing

let phoneRef = Reference(Substring.self)

let phonePattern = Regex {
 Optionally {
 "+1 "
 }
 Capture(as: phoneRef) {
 "(" + Repeat(3) { .digit } + ") "
 Repeat(3) { .digit }
 "-"
 Repeat(4) { .digit }
 }
}

Date Format Parsing

let datePattern = Regex {
 Capture { Repeat(4) { .digit } }
 "-"
 Capture { Repeat(2) { .digit } }
 "-"
 Capture { Repeat(2) { .digit } }
}

These practical patterns form the foundation of form validation in modern applications.

RegexBuilder vs Traditional Regex

Readability and Maintainability

When to Use Each Approach

Use RegexBuilder when:

• Building complex patterns
• Patterns need long-term maintenance
• Type safety is important
• Multiple team members work with the code

Use Traditional Regex when:

• Simple, one-off patterns
• Interoperating with regex strings
• Maximum brevity is needed
• Legacy system compatibility required

Our software development team recommends RegexBuilder for any production code that requires maintainability and type safety.

Best Practices

Start Simple and Build Incrementally

When tackling complex pattern matching needs, resist the urge to write the entire pattern at once. Start with a simple pattern that matches the basic structure, verify it works with test data, then add complexity gradually.

Use Named Captures Liberally

Even for patterns with only one or two captures, using named captures improves code clarity:

// Create references as constants
let emailRef = Reference(Substring.self)
let domainRef = Reference(Substring.self)

// Use meaningful names in your pattern
let pattern = Regex {
 Capture(as: emailRef) { ... }
 "@"
 Capture(as: domainRef) { ... }
}

Extract Reusable Components

Create functions for common patterns:

func emailPattern() -> Regex<Substring> {
 Regex { ... }
}

func phonePattern() -> Regex<Substring> {
 Regex { ... }
}

Following these best practices ensures your regex patterns remain maintainable as your application grows.

Sources

1. LogRocket: Getting started with RegexBuilder on Swift - Comprehensive tutorial covering basic usage, quantifiers, and practical examples for iOS developers
2. Hacking with Swift: Regular expressions - Swift 5.7 - In-depth coverage of Swift 5.7 regex improvements, RegexBuilder DSL, and compile-time validation
3. Kodeco: Swift Regex Tutorial: Getting Started - Practical examples with real-world pattern matching scenarios
4. Apple Swift Evolution SE-0351 - Official proposal for RegexBuilder DSL