Struct-based regular expressions for Go

Match regular expressions into struct fields

go get github.com/alexflint/go-restructure

This package allows you to express regular expressions by defining a struct, and then capture matched sub-expressions into struct fields. Here is a very simple email address parser:

import "github.com/alexflint/go-restructure"
type EmailAddress struct { 	_    struct{} ^ 	User string   \w+ 	_    struct{} @ 	Host string   [^@]+ 	_    struct{} $ }
func main() { 	var addr EmailAddress 	restructure.Find(&addr, "joe@example.com") 	fmt.Println(addr.User) // prints "joe" 	fmt.Println(addr.Host) // prints "example.com" }

The regular expression that was executed was the concatenation of the struct tags:

^(\w+)@([^@]+)$

The first submatch was inserted into the User field and the second into the Host field.

You may also use the regexp: tag key, but keep in mind that you must escape quotes and backslashes:

type EmailAddress struct {
	_    string regexp:"^"
	User string regexp:"\\w+"
	_    string regexp:"@"
	Host string regexp:"[^@]+"
	_    string regexp:"$"
}

Nested Structs

Here is a slightly more sophisticated email address parser that uses nested structs:

type Hostname struct {
	Domain string   \w+
	_      struct{} \.
	TLD    string   \w+
}
type EmailAddress struct { 	_    struct{} ^ 	User string   [a-zA-Z0-9._%+-]+ 	_    struct{} @ 	Host *Hostname 	_    struct{} $ }
func main() { 	var addr EmailAddress 	success, _ := restructure.Find(&addr, "joe@example.com") 	if success { 		fmt.Println(addr.User)        // prints "joe" 		fmt.Println(addr.Host.Domain) // prints "example" 		fmt.Println(addr.Host.TLD)    // prints "com" 	} }

Compare this to using the standard library regexp.FindStringSubmatchIndex directly:

func main() {
	content := "joe@example.com"
	expr := regexp.MustCompile(^([a-zA-Z0-9._%+-]+)@((\w+)\.(\w+))$)
	indices := expr.FindStringSubmatchIndex(content)
	if len(indices) > 0 {
		userBegin, userEnd := indices[2], indices[3]
		var user string
		if userBegin != -1 && userEnd != -1 {
			user = content[userBegin:userEnd]
		}
domainBegin, domainEnd := indices[6], indices[7] 		var domain string 		if domainBegin != -1 && domainEnd != -1 { 			domain = content[domainBegin:domainEnd] 		}
tldBegin, tldEnd := indices[8], indices[9] 		var tld string 		if tldBegin != -1 && tldEnd != -1 { 			tld = content[tldBegin:tldEnd] 		}
fmt.Println(user)   // prints "joe" 		fmt.Println(domain) // prints "example" 		fmt.Println(tld)    // prints "com" 	} }

Ints

It is also possible to set struct fields as int to get the string automatically converted.

// Matches "12 wombats", "1 wombat" and store the number as int
type Wisdom struct {
	Number   int       ^\d+
	_   	 string    \s+
	Animal   string    \w+
}

Optional fields

When nesting one struct within another, you can make the nested struct optional by marking it with ?. The following example parses floating point numbers with optional sign and exponent:

// Matches "123", "1.23", "1.23e-4", "-12.3E+5", ".123"
type Float struct {
	Sign     *Sign     ?      // sign is optional
	Whole    string    [0-9]*
	Period   struct{}  \.?
	Frac     string    [0-9]+
	Exponent *Exponent ?      // exponent is optional
}
// Matches "e+4", "E6", "e-03" type Exponent struct { 	_    struct{} [eE] 	Sign *Sign    ?         // sign is optional 	Num  string   [0-9]+ }
// Matches "+" or "-" type Sign struct { 	Ch string [+-] }

When an optional sub-struct is not matched, it will be set to nil:

"1.23" -> {
  "Sign": nil,
  "Whole": "1",
  "Frac": "23",
  "Exponent": nil
}
"1.23e+45" -> {   "Sign": nil,   "Whole": "1",   "Frac": "23",   "Exponent": {     "Sign": {       "Ch": "+"     },     "Num": "45"   } }

Finding multiple matches

The following example uses Regexp.FindAll to extract all floating point numbers from a string, using the same Float struct as in the example above.

src := "There are 10.4 cats for every 100 dogs in the United States."
floatRegexp := restructure.MustCompile(Float{}, restructure.Options{})
var floats []Float
floatRegexp.FindAll(&floats, src, -1)

To limit the number of matches set the third parameter to a positive number.

Getting begin and end positions for submatches

To get the begin and end position of submatches, use the restructure.Submatch struct in place of string:

Here is an example of matching python imports such as import foo as bar:

type Import struct {
	_       struct{}             ^import\s+
	Package restructure.Submatch \w+
	_       struct{}             \s+as\s+
	Alias   restructure.Submatch \w+
}
var importRegexp = restructure.MustCompile(Import{}, restructure.Options{})
func main() { 	var imp Import 	importRegexp.Find(&imp, "import foo as bar") 	fmt.Printf("IMPORT %s (bytes %d...%d)\n", imp.Package.String(), imp.Package.Begin, imp.Package.End) 	fmt.Printf("    AS %s (bytes %d...%d)\n", imp.Alias.String(), imp.Alias.Begin, imp.Alias.End) }

IMPORT foo (bytes 7...10)     AS bar (bytes 14...17)

Regular expressions inside JSON

To run a regular expression as part of a json unmarshal, just implement the JSONUnmarshaler interface. Here is an example that parses the following JSON string containing a quaternion:

{
	"Var": "foo",
	"Val": "1+2i+3j+4k"
}

First we define the expressions for matching quaternions in the form 1+2i+3j+4k:

// Matches "1", "-12", "+12"
type RealPart struct {
	Sign string regexp:"[+-]?"
	Real string regexp:"[0-9]+"
}
// Matches "+123", "-1" type SignedInt struct { 	Sign string regexp:"[+-]" 	Real string regexp:"[0-9]+" }
// Matches "+12i", "-123i" type IPart struct { 	Magnitude SignedInt 	_         struct{} regexp:"i" }
// Matches "+12j", "-123j" type JPart struct { 	Magnitude SignedInt 	_         struct{} regexp:"j" }
// Matches "+12k", "-123k" type KPart struct { 	Magnitude SignedInt 	_         struct{} regexp:"k" }
// matches "1+2i+3j+4k", "-1+2k", "-1", etc type Quaternion struct { 	Real *RealPart 	I    *IPart regexp:"?" 	J    *JPart regexp:"?" 	K    *KPart regexp:"?" }
// matches the quoted strings "-1+2i", "3-4i", "12+34i", etc type QuotedQuaternion struct { 	_          struct{} regexp:"^" 	_          struct{} regexp:"\"" 	Quaternion *Quaternion 	_          struct{} regexp:"\"" 	_          struct{} regexp:"$" }

Next we implement UnmarshalJSON for the QuotedQuaternion type:

var quaternionRegexp = restructure.MustCompile(QuotedQuaternion{}, restructure.Options{})

func (c *QuotedQuaternion) UnmarshalJSON(b []byte) error { 	if !quaternionRegexp.Find(c, string(b)) { 		return fmt.Errorf("%s is not a quaternion", string(b)) 	} 	return nil }

Now we can define a struct and unmarshal JSON into it:

type Var struct { 	Name  string 	Value *QuotedQuaternion }

func main() { 	src := {"name": "foo", "value": "1+2i+3j+4k"} 	var v Var 	json.Unmarshal([]byte(src), &v) }

{   "Name": "foo",   "Value": {     "Quaternion": {       "Real": {         "Sign": "",         "Real": "1"       },       "I": {         "Magnitude": {           "Sign": "+",           "Real": "2"         }       },       "J": {         "Magnitude": {           "Sign": "+",           "Real": "3"         }       },       "K": {         "Magnitude": {           "Sign": "+",           "Real": "4"         }       }     }   } }

Index of examples

• Parse an email address
• Parse an email address using nested structs
• Parse a floating point number
• Find all floats in a string
• Parse a dotted name
• Parse a python import statement
• Regular expression inside a JSON struct

Benchmarks

See benchmarks document