Match regex expression named groups into go struct using struct tags and automatic parsing

# regroup
Simple library to match regex expression named groups into go struct using struct tags and automatic parsing

![](https://github.com/oriser/regroup/workflows/reviewdog/badge.svg)
![](https://github.com/oriser/regroup/workflows/Go/badge.svg)
[![codecov](https://codecov.io/gh/oriser/regroup/branch/master/graph/badge.svg)](https://codecov.io/gh/oriser/regroup)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/oriser/regroup)](https://pkg.go.dev/github.com/oriser/regroup)
[![Go Report Card](https://goreportcard.com/badge/github.com/oriser/regroup?a=b)](https://goreportcard.com/report/github.com/oriser/regroup)
[![codeclimate](https://api.codeclimate.com/v1/badges/169ebfa87cb6af0c6db6/maintainability)](https://goreportcard.com/report/github.com/oriser/regroup)

### Installing
`go get github.com/oriser/regroup`


## Example
#### Named groups map
```go
package main

import (
	"fmt"
	"github.com/oriser/regroup"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

func main() {
	matches, err := re.Groups("5s 123 bar")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", matches)
}
```
Will output:
`map[duration:5s foo:bar num:123]`

#### Single match
```go
package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	if err := re.MatchToTarget("5s 123 bar", a); err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", a)
}

```
Will output:
`&{Number:123 Dur:5s AnotherStruct:{Str:bar}}`

#### Multiple matches
You can also get all matches parsed as given target struct. The return value in this
case will be an array of interfaces, you should cast it to the target type in order to access its fields.
```go
package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`\s*(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	s := `5s 123 bar1
		  1m 456 bar2
		  10h 789 bar3`
	rets, err := re.MatchAllToTarget(s, -1, a)
	if err != nil {
		panic(err)
	}
	for _, elem := range rets {
		fmt.Printf("%+v\n", elem.(*A))
	}
}

```
Will output:
```
&{Number:123 Dur:5s AnotherStruct:{Str:bar1}}
&{Number:456 Dur:1m0s AnotherStruct:{Str:bar2}}
&{Number:789 Dur:10h0m0s AnotherStruct:{Str:bar3}}
```

#### Required groups
You can specify that a specific group is required, means that it can't be empty.

If a required group is empty, an error (`*regroup.RequiredGroupIsEmpty`) will be returned .
```go
package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo,required"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	if err := re.MatchToTarget("5s 123 ", a); err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", a)
}
```
Will return an error: `required regroup "foo" is empty for field "Str"`

### Existence Match Groups
You can check for the presence of an optional group using a `bool` with the `exists` tag.

```go
package main

type Exist struct {
	IsAdmin bool `regroup:"is_admin,exists"`
}

func main() {
	r := MustCompile(`^(?P<name>\w*)(?:,(?P<is_admin>admin))?$`)
	parsed := &Exist{}
	if err := r.MatchToTarget("bob_smith", parsed); err != nil {
		panic(err)
	}
	fmt.Printf("%t\n", parsed.IsAdmin)
}
```

This example would print `false`. However if the input were `bob_smith,admin` it would print `true`. When using the `exists` tag, make ure that you regular expression has an optional group and matches all the expected input patterns.

## Supported struct field types
- `time.Duration`
- `bool`
- `string`
- `int`
- `int8`
- `int16`
- `int32`
- `int64`
- `uint`
- `uint8`
- `uint16`
- `uint32`
- `uint64`
- `float32`
- `float64`

Pointers and nested structs are also supported, both on single match and multiple matches


regroup

Production regex engine with Rust regex-crate architecture: multi-engine DFA/NFA, SIMD prefilters, drop-in stdlib replacement

# coregex

[![GitHub Release](https://img.shields.io/github/v/release/coregx/coregex?style=flat-square&logo=github&color=blue)](https://github.com/coregx/coregex/releases/latest)
[![Go Version](https://img.shields.io/github/go-mod/go-version/coregx/coregex?style=flat-square&logo=go)](https://go.dev/dl/)
[![Go Reference](https://pkg.go.dev/badge/github.com/coregx/coregex.svg)](https://pkg.go.dev/github.com/coregx/coregex)
[![CI](https://img.shields.io/github/actions/workflow/status/coregx/coregex/test.yml?branch=main&style=flat-square&logo=github-actions&label=CI)](https://github.com/coregx/coregex/actions)
[![Go Report Card](https://goreportcard.com/badge/github.com/coregx/coregex?style=flat-square)](https://goreportcard.com/report/github.com/coregx/coregex)
[![codecov](https://codecov.io/gh/coregx/coregex/branch/main/graph/badge.svg)](https://codecov.io/gh/coregx/coregex)
[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
[![GitHub Stars](https://img.shields.io/github/stars/coregx/coregex?style=flat-square&logo=github)](https://github.com/coregx/coregex/stargazers)
[![GitHub Issues](https://img.shields.io/github/issues/coregx/coregex?style=flat-square&logo=github)](https://github.com/coregx/coregex/issues)
[![GitHub Discussions](https://img.shields.io/github/discussions/coregx/coregex?style=flat-square&logo=github)](https://github.com/coregx/coregex/discussions)

High-performance regex engine for Go. Drop-in replacement for `regexp` with **3-3000x speedup**.\*

<sub>\* Typical speedup 15-240x on real-world patterns. 1000x+ achieved on [specific edge cases](https://github.com/kolkov/regex-bench#extreme-speedups-1000-3000x) where prefilters skip entire input (e.g., IP pattern on text with no digits).</sub>

## Why coregex?

Go's stdlib `regexp` is intentionally simple — single NFA engine, no optimizations. This guarantees O(n) time but leaves performance on the table.

coregex brings Rust regex-crate architecture to Go:
- **Multi-engine**: 17 strategies — Lazy DFA, PikeVM, OnePass, BoundedBacktracker, and more
- **SIMD prefilters**: AVX2/SSSE3 for fast candidate rejection
- **Reverse search**: Suffix/inner literal patterns run 1000x+ faster
- **O(n) guarantee**: No backtracking, no ReDoS vulnerabilities

## Installation

```bash
go get github.com/coregx/coregex
```

Requires Go 1.25+. Minimal dependencies (`golang.org/x/sys`, `github.com/coregx/ahocorasick`).

## Quick Start

```go
package main

import (
    "fmt"
    "github.com/coregx/coregex"
)

func main() {
    re := coregex.MustCompile(`\w+@\w+\.\w+`)

    text := []byte("Contact support@example.com for help")

    // Find first match
    fmt.Printf("Found: %s\n", re.Find(text))

    // Check if matches (zero allocation)
    if re.MatchString("test@email.com") {
        fmt.Println("Valid email format")
    }
}
```

## Performance

Cross-language benchmarks on 6MB input, AMD EPYC ([source](https://github.com/kolkov/regex-bench)):

| Pattern | Go stdlib | coregex | Rust regex | vs stdlib | vs Rust |
|---------|-----------|---------|------------|-----------|---------|
| Literal alternation | 554 ms | 4.5 ms | 0.72 ms | **122x** | 6.2x slower |
| Multi-literal | 1572 ms | 12.4 ms | 5.5 ms | **126x** | 2.2x slower |
| Inner `.*keyword.*` | 238 ms | 0.27 ms | 0.33 ms | **881x** | **1.2x faster** |
| Suffix `.*\.txt` | 239 ms | 1.9 ms | 1.2 ms | **125x** | 1.5x slower |
| Multiline `(?m)^/.*\.php` | 102 ms | 0.34 ms | 0.75 ms | **299x** | **2.2x faster** |
| Email validation | 257 ms | 0.46 ms | 0.31 ms | **557x** | 1.4x slower |
| URL extraction | 256 ms | 0.62 ms | 0.37 ms | **413x** | 1.6x slower |
| IP address | 494 ms | 0.72 ms | 13.5 ms | **685x** | **18.8x faster** |
| Version `\d+.\d+.\d+` | 164 ms | 0.62 ms | 0.79 ms | **263x** | **1.2x faster** |
| Char class `[\w]+` | 478 ms | 42.1 ms | 56.4 ms | **11x** | **1.3x faster** |
| Word repeat `(\w{2,8})+` | 690 ms | 180 ms | 54.7 ms | **3x** | 3.2x slower |

**Where coregex excels:**
- Multiline patterns (`(?m)^/.*\.php`) — **2.2x faster than Rust**, 299x vs stdlib
- IP/phone patterns (`\d+\.\d+\.\d+\.\d+`) — SIMD digit prefilter skips non-digit regions
- Suffix patterns (`.*\.log`, `.*\.txt`) — reverse search optimization (1000x+)
- Inner literals (`.*error.*`, `.*@example\.com`) — bidirectional DFA (900x+)
- Multi-pattern (`foo|bar|baz|...`) — Slim Teddy (≤32), Fat Teddy (33-64), or Aho-Corasick (>64)
- Anchored alternations (`^(\d+|UUID|hex32)`) — O(1) branch dispatch (5-20x)
- Concatenated char classes (`[a-zA-Z]+[0-9]+`) — DFA with byte classes (5-7x)
- **Zero-alloc iterators** (`AllIndex`, `AppendAllIndex`) — 0 heap allocs, up to **30% faster** than FindAll. Email pattern **faster than Rust** with `AppendAllIndex`.

## Features

### Engine Selection

coregex automatically selects the optimal engine:

| Strategy | Pattern Type | Speedup |
|----------|--------------|---------|
| **AnchoredLiteral** | `^prefix.*suffix$` | **32-133x** |
| **MultilineReverseSuffix** | `(?m)^/.*\.php` | **100-552x** ⚡ |
| ReverseInner | `.*keyword.*` | 100-900x |
| ReverseSuffix | `.*\.txt` | 100-1100x |
| BranchDispatch | `^(\d+\|UUID\|hex32)` | 5-20x |
| CompositeSequenceDFA | `[a-zA-Z]+[0-9]+` | 5-7x |
| LazyDFA | IP, complex patterns | 10-150x |
| AhoCorasick | `a\|b\|c\|...\|z` (>64 patterns) | 75-113x |
| CharClassSearcher | `[\w]+`, `\d+` | 4-25x |
| Slim Teddy | `foo\|bar\|baz` (2-32 patterns) | 15-240x |
| Fat Teddy | 33-64 patterns | 60-73x |
| OnePass | Anchored captures | 10x |
| BoundedBacktracker | Small patterns | 2-5x |

### API Compatibility

Drop-in replacement for `regexp.Regexp`:

```go
// stdlib
re := regexp.MustCompile(pattern)

// coregex — same API
re := coregex.MustCompile(pattern)
```

Supported methods:
- `Match`, `MatchString`, `MatchReader`
- `Find`, `FindString`, `FindAll`, `FindAllString`
- `FindIndex`, `FindStringIndex`, `FindAllIndex`
- `FindSubmatch`, `FindStringSubmatch`, `FindAllSubmatch`
- `ReplaceAll`, `ReplaceAllString`, `ReplaceAllFunc`
- `Split`, `SubexpNames`, `NumSubexp`
- `Longest`, `Copy`, `String`

### Zero-Allocation APIs

```go
// Zero allocations — boolean match
matched := re.IsMatch(text)

// Zero allocations — single match indices
start, end, found := re.FindIndices(text)

// Zero allocations — iterator over all matches (Go 1.23+)
for m := range re.AllIndex(data) {
    fmt.Printf("match at [%d, %d]\n", m[0], m[1])
}

// Zero allocations — match content iterator
for s := range re.AllString(text) {
    fmt.Println(s)
}

// Buffer-reuse — append to caller's slice (strconv.Append* pattern)
var buf [][2]int
for _, chunk := range chunks {
    buf = re.AppendAllIndex(buf[:0], chunk, -1)
    process(buf)
}
```

### Configuration

```go
config := coregex.DefaultConfig()
config.DFAMaxStates = 10000      // Limit DFA cache
config.EnablePrefilter = true    // SIMD acceleration

re, err := coregex.CompileWithConfig(pattern, config)
```

### Thread Safety

A compiled `*Regexp` is safe for concurrent use by multiple goroutines:

```go
re := coregex.MustCompile(`\d+`)

// Safe: multiple goroutines sharing one compiled pattern
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        re.FindString("test 123 data")  // thread-safe
    }()
}
wg.Wait()
```

Internally uses `sync.Pool` (same pattern as Go stdlib `regexp`) for per-search state management.

## Syntax Support

Uses Go's `regexp/syntax` parser:

| Feature | Support |
|---------|---------|
| Character classes | `[a-z]`, `\d`, `\w`, `\s` |
| Quantifiers | `*`, `+`, `?`, `{n,m}` |
| Anchors | `^`, `$`, `\b`, `\B` |
| Groups | `(...)`, `(?:...)`, `(?P<name>...)` |
| Unicode | `\p{L}`, `\P{N}` |
| Flags | `(?i)`, `(?m)`, `(?s)` |
| Backreferences | Not supported (O(n) guarantee) |

## Architecture

```
Pattern → Parse → NFA → Literal Extract → Strategy Select
                                               ↓
                  ┌────────────────────────────────────────────┐
                  │ Engines (17 strategies):                   │
                  │  LazyDFA, PikeVM, OnePass,                 │
                  │  BoundedBacktracker, ReverseAnchored,      │
                  │  ReverseInner, ReverseSuffix,              │
                  │  ReverseSuffixSet, MultilineReverseSuffix, │
                  │  AnchoredLiteral, CharClassSearcher,       │
                  │  Teddy, DigitPrefilter, AhoCorasick,       │
                  │  CompositeSearcher, BranchDispatch, Both   │
                  └────────────────────────────────────────────┘
                                               ↓
Input → Prefilter (SIMD) → Engine → Match Result
```

> For detailed architecture documentation, see [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
> For optimization details, see [docs/OPTIMIZATIONS.md](docs/OPTIMIZATIONS.md).

**SIMD Primitives** (AMD64):
- `memchr` — single byte search (AVX2)
- `memmem` — substring search (SSSE3)
- `Slim Teddy` — multi-pattern search, 2-32 patterns (SSSE3, 9+ GB/s)
- `Fat Teddy` — multi-pattern search, 33-64 patterns (AVX2, 9+ GB/s)

Pure Go fallback on other architectures.

## Battle-Tested

coregex was [tested in GoAWK](https://github.com/benhoyt/goawk/pull/264). This real-world testing uncovered 15+ edge cases that synthetic benchmarks missed.

### Powered by coregex: uawk

[uawk](https://github.com/kolkov/uawk) is a modern AWK interpreter built on coregex:

| Benchmark (10MB) | GoAWK | uawk | Speedup |
|------------------|-------|------|---------|
| Regex alternation | 1.85s | 97ms | **19x** |
| IP matching | 290ms | 99ms | **2.9x** |
| General regex | 320ms | 100ms | **3.2x** |

```bash
go install github.com/kolkov/uawk/cmd/uawk@latest
uawk '/error/ { print $0 }' server.log
```

**We need more testers!** If you have a project using `regexp`, try coregex and [report issues](https://github.com/coregx/coregex/issues).

## Documentation

- [API Reference](https://pkg.go.dev/github.com/coregx/coregex)
- [CHANGELOG](CHANGELOG.md)
- [Contributing](CONTRIBUTING.md)
- [Security Policy](SECURITY.md)

## Comparison

| | coregex | stdlib | regexp2 |
|---|---------|--------|---------|
| Performance | 3-3000x faster | Baseline | Slower |
| SIMD | AVX2/SSSE3 | No | No |
| O(n) guarantee | Yes | Yes | No |
| Backreferences | No | No | Yes |
| API | Drop-in | — | Different |

**Use coregex** for performance-critical code with O(n) guarantee.
**Use stdlib** for simple cases where performance doesn't matter.
**Use regexp2** if you need backreferences (accept exponential worst-case).

## Related

- [uawk](https://github.com/kolkov/uawk) — Ultra AWK interpreter powered by coregex
- [kolkov/regex-bench](https://github.com/kolkov/regex-bench) — Cross-language benchmarks
- [golang/go#26623](https://github.com/golang/go/issues/26623) — Go regexp performance discussion
- [golang/go#76818](https://github.com/golang/go/issues/76818) — Upstream path proposal

**Inspired by:**
- [Rust regex](https://github.com/rust-lang/regex) — Architecture
- [RE2](https://github.com/google/re2) — O(n) guarantees
- [Hyperscan](https://github.com/intel/hyperscan) — SIMD algorithms

## License

MIT — see [LICENSE](LICENSE).

---

**Status:** Pre-1.0 (API may change). Ready for testing and feedback.

[Releases](https://github.com/coregx/coregex/releases) · [Issues](https://github.com/coregx/coregex/issues) · [Discussions](https://github.com/coregx/coregex/discussions)

## Star History

<a href="https://star-history.com/#coregx/coregex&Date">
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=coregx/coregex&type=Date&theme=dark" />
   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=coregx/coregex&type=Date" />
   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=coregx/coregex&type=Date" />
 </picture>
</a>


coregex

Count and expand Regular Expressions into all matching Strings

# genex [![GoDoc](https://godoc.org/github.com/alixaxel/genex?status.svg)](https://godoc.org/github.com/alixaxel/genex) [![GoCover](http://gocover.io/_badge/github.com/alixaxel/genex)](http://gocover.io/github.com/alixaxel/genex) [![Go Report Card](https://goreportcard.com/badge/github.com/alixaxel/genex)](https://goreportcard.com/report/github.com/alixaxel/genex)

Genex package for Go

Easy and efficient package to expand any given regex into all the possible strings that it can match.

This is the code that powers [namegrep](https://namegrep.com/).

## Usage

```go
package main

import (
    "fmt"
    "regexp/syntax"

    "github.com/alixaxel/genex"
)

func main() {
    charset, _ := syntax.Parse(`[0-9a-z]`, syntax.Perl)

    if input, err := syntax.Parse(`(foo|bar|baz){1,2}\d`, syntax.Perl); err == nil {
    	fmt.Println("Count:", genex.Count(input, charset, 3))

    	genex.Generate(input, charset, 3, func(output string) {
    		fmt.Println("[*]", output)
    	})
    }
}
```

## Output

```
Count: 120

[*] foo0
[*] ...
[*] foo9
[*] foofoo0
[*] ...
[*] foofoo9
[*] foobar0
[*] ...
[*] foobar9
[*] foobaz0
[*] ...
[*] foobaz9
[*] bar0
[*] ...
[*] bar9
[*] barfoo0
[*] ...
[*] barfoo9
[*] barbar0
[*] ...
[*] barbar9
[*] barbaz0
[*] ...
[*] barbaz9
[*] baz0
[*] ...
[*] baz9
[*] bazfoo0
[*] ...
[*] bazfoo9
[*] bazbar0
[*] ...
[*] bazbar9
[*] bazbaz0
[*] ...
[*] bazbaz9
```

## Install

	go get github.com/alixaxel/genex

## License

MIT


genex

# Rex

![Version](https://img.shields.io/github/v/tag/hedhyw/rex)
[![Go Report Card](https://goreportcard.com/badge/github.com/hedhyw/rex)](https://goreportcard.com/report/github.com/hedhyw/rex)
[![Coverage Status](https://coveralls.io/repos/github/hedhyw/rex/badge.svg?branch=main)](https://coveralls.io/github/hedhyw/rex?branch=main)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/hedhyw/rex)](https://pkg.go.dev/github.com/hedhyw/rex?tab=doc)

![rex-gopher](_docs/gopher.png)

**This is a regular expressions builder for gophers!**

- **[Why?](#why)**
- **[FAQ](#faq)**
- **[Documentation](_docs/library.md)**
- **[Examples](pkg/rex/examples_test.go)**
- **[License](#license)**

## Why?

It makes readability better and helps to construct regular expressions using human-friendly constructions. Also, it allows commenting and reusing blocks, which improves the quality of code. It provides a convenient way to use parameterized patterns. It is easy to implement custom patterns or use a combination of others.

It is just a builder, so it returns standart [`*regexp.Regexp`](https://pkg.go.dev/regexp#Regexp).

The library supports [groups](_docs/library.md#groups), [composits](_docs/library.md#groups), [classes](_docs/library.md#character-classes), [flags](_docs/library.md#flags), [repetitions](_docs/library.md#repetitions) and if you want you can even use `raw regular expressions` in any place. Also it contains a set of [predefined helpers](_docs/library.md#helper) with patterns for number ranges, phones, emails, etc...

Let's see an example of validating or matching `someid[#]` using a verbose pattern:
```golang
re := rex.New(
    rex.Chars.Begin(), // `^`
    // ID should begin with lowercased character.
    rex.Chars.Lower().Repeat().OneOrMore(), // `[a-z]+`
    // ID should contain number inside brackets [#].
    rex.Group.NonCaptured( // (?:)
        rex.Chars.Single('['),                   // `[`
        rex.Chars.Digits().Repeat().OneOrMore(), // `[0-9]+`
        rex.Chars.Single(']'),                   // `]`
    ),
    rex.Chars.End(), // `$`
).MustCompile()
```

Yes, it requires more code, but it has its advantages.
> More, but simpler code, fewer bugs.

You can still use original regular expressions as is in any place. Example of
matching numbers between `-111.99` and `1111.99` using a combination of
patterns and raw regular expression:

```golang
re := rex.New(
    rex.Common.Raw(`^`),
    rex.Helper.NumberRange(-111, 1111),
    rex.Common.RawVerbose(`
        # RawVerbose is a synonym to Raw,
        # but ignores comments, spaces and new lines.
        \.        # Decimal delimter.  
        [0-9]{2}  # Only two digits.
        $         # The end.
    `),
).MustCompile()

// Produces:
// ^((?:\x2D(?:0|(?:[1-9])|(?:[1-9][0-9])|(?:10[0-9])|(?:11[0-1])))|(?:0|(?:[1-9])|(?:[1-9][0-9])|(?:[1-9][0-9][0-9])|(?:10[0-9][0-9])|(?:110[0-9])|(?:111[0-1])))\.[0-9]{2}$
```

> The style you prefer is up to you.

## Meme

<img alt="Drake Hotline Bling meme" width=350px src="_docs/meme.png" />

## FAQ

1. **It is too verbose. Too much code.**

    More, but simpler code, fewer bugs.
    Anyway, you can still use the raw regular expressions syntax in combination with helpers.
    ```golang
    rex.New(
        rex.Chars.Begin(),
        rex.Group.Define(
            // `Raw` can be placed anywhere in blocks.
            rex.Common.Raw(`[a-z]+\d+[A-Z]*`),
        ),
        rex.Chars.End(),
    )
    ```
    Or just raw regular expression with comments:
    ```golang
    rex.Common.RawVerbose(`
        ^                # Start of the line.
        [a-zA-Z0-9]+     # Local part.
        @                # delimeter.
        [a-zA-Z0-9\.]+   # Domain part.
        $                # End of the line.
    `)
    ```

2. **Should I know regular expressions?**

   It is better to know them in order to use this library most effectively.
   But in any case, it is not strictly necessary.

3. **Is it language-dependent? Is it transferable to other languages?**

   We can use this library only in Go. If you want to use any parts
   in other places, then just call `rex.New(...).String()` and copy-paste
   generated regular expression.

4. **What about my favourite `DSL`?**

   Every IDE has convenient auto-completion for languages. So all helpers
   of this library are easy to use out of the box. Also, it is easier
   to create custom parameterized helpers.

5. **Is it stable?**

   Yes, starting with version v1.0.0.

6. **I have another question. I found an issue. I have a feature request. I want to contribute.**

   Please, [create an issue](https://github.com/hedhyw/rex/issues/new?labels=question&title=I+have+a+question).

## License

- The library is under [MIT Lecense](LICENSE)
- [The gopher](_docs/gopher.png) is under [Creative Commons Attribution 3.0](https://creativecommons.org/licenses/by/3.0/) license. It was originally created by [Renée French](https://en.wikipedia.org/wiki/Ren%C3%A9e_French) and redrawed by me.
- [The meme](_docs/meme.png) contains two frame fragments from [the video](https://www.youtube.com/watch?v=uxpDa-c-4Mc).


Simple and lightweight wildcard pattern matching

# Go-wildcard

[![Go Report Card](https://goreportcard.com/badge/github.com/IGLOU-EU/go-wildcard/v2)](https://goreportcard.com/report/github.com/IGLOU-EU/go-wildcard/v2)
[![Go Reference](https://img.shields.io/badge/api-reference-blue)](https://pkg.go.dev/github.com/IGLOU-EU/go-wildcard/v2)
[![BSD 3 Clause ](https://img.shields.io/badge/license-BSD_3_Clause-blue)](https://opensource.org/license/bsd-3-clause/)

## 💡 Why
The purpose of this library is to provide a simple and fast wildcard pattern matching.
Regex are much more complex and slower (even prepared regex)... and the filepath.Match is file-name-centric.

So, this library is a very fast and very simple alternative to regex and not tied to filename semantics unlike filepath.Match. 
There are no dependencies and is alocation free. 🥳

## 🧰 Features
There are the supported patterns operators:
- `*` match zero or more characters
- `?` match zero or one character
- `.` match exactly one character

## 🧐 How to
>⚠️ WARNING: Unlike the GNU "libc", this library have no equivalent to "FNM_FILE_NAME". 
>To do this you can use "path/filepath" https://pkg.go.dev/path/filepath#Match

There is super simple to use this library, you just have to import it and use the Match function.
```go
package main

import (
	"fmt"

	"github.com/IGLOU-EU/go-wildcard/v2"
)

func main() {
    str := "daaadabadmanda"
    pattern := "?a*da*d.?*"

    resultM := wildcard.Match(pattern, str) // Fastest way but can't use '?' or '." with rune multiple byte representation
    resultMFB = wildcard.MatchFromByte([]byte(pattern), []byte(str)) // Same as Match to avoid convertion (bad example here)
    resultMBR = wildcard.MatchByRune(pattern, str) // Slower than Match but with strict rune comparison (not grapheme cluster)

	fmt.Println(str, pattern, result)
}
```

## 🛸 Benchmark
The benchmark is done with the following command:
```bash
go test -benchmem -bench . github.com/IGLOU-EU/go-wildcard/v2/benchmark
```

```yml
goos: linux
goarch: amd64
pkg: github.com/IGLOU-EU/go-wildcard/v2
cpu: AMD Ryzen 7 PRO 6850U with Radeon Graphics  
```

The tested fonctions are:
- regexp.MatchString
- filepath.Match
- oldMatchSimple `From the commit a899be92514ed08aa5271bc3b93320b719ce2114`
- oldMatch `From the commit a899be92514ed08aa5271bc3b93320b719ce2114`
- Match `From string with byte comparison`
- MatchByRune `From string with rune comparison`
- MatchFromByte `From byte slice with byte comparison`

![time bench](./assets/graph_time.png)
![allocs bench](./assets/graph_allocs.png)

## 🕰 History 
Originally, this library was a fork from the Minio project.
The purpose was to give access to this "lib" under Apache license, without importing the entire Minio project.
And to keep it usable under the Apache License Version 2.0 after MinIO project is migrated to GNU Affero General Public License 3.0 or later from [`update license change for MinIO`](https://github.com/minio/minio/commit/069432566fcfac1f1053677cc925ddafd750730a)

The actual Minio wildcard matching code can be found in [`wildcard.go`](https://github.com/minio/pkg/tree/main/wildcard)

go-wildcard

Library for generating random strings from regular expressions

#goregen [![GoDoc](https://godoc.org/github.com/zach-klippenstein/goregen?status.svg)](https://godoc.org/github.com/zach-klippenstein/goregen) [![Build Status](https://travis-ci.org/zach-klippenstein/goregen.svg?branch=master)](https://travis-ci.org/zach-klippenstein/goregen)

A Golang library for generating random strings from regular expressions.

Checkout https://goregen-demo.herokuapp.com for a live demo.

See the [godoc](https://godoc.org/github.com/zach-klippenstein/goregen) for examples.


The Best Go Libraries For Text Processing - Regular Expressions (6)

regroup

coregex

genex

rex

go-wildcard

goregen