Use method instead of function

cmd/main.go

@@ -121,12 +121,12 @@ func main() {
 		}
 		matchIndices := make([]reg.Match, 0)
 		if matchNumFlagEnabled {
-			tmp, err := reg.FindNthMatch(regComp, test_str, *matchNum)
+			tmp, err := regComp.FindNthMatch(test_str, *matchNum)
 			if err == nil {
 				matchIndices = append(matchIndices, tmp)
 			}
 		} else {
-			matchIndices = reg.FindAllMatches(regComp, test_str)
+			matchIndices = regComp.FindAllSubmatch(test_str)
 		}
 
 		if *printMatchesFlag {

regex/doc.go

@@ -84,6 +84,17 @@ Assertions:
 	\b				Match at a word boundary (a word character followed by a non-word character, or vice-versa)
 	\B				Match at a non-word boundary (a word character followed by a word character, or vice-versa)
 
+Lookarounds:
+
+	x(?=y)			Positive lookahead - Match x if followed by y
+	x(?!y)			Negative lookahead - Match x if NOT followed by y
+	(?<=x)y			Positive lookbehind - Match y if preceded by x
+	(?<!x)y			Negative lookbehind - Match y if NOT preceded by x
+
+Numeric ranges:
+
+	<x-y>			Match any number from x to y (inclusive) (x and y must be positive numbers)
+
 # Flags
 
 Flags are used to change the behavior of the engine. None of them are enabled by default. They are passed as variadic arguments to [Compile].

regex/matching.go

@@ -57,6 +57,11 @@ func (g Group) isValid() bool {
 	return g.StartIdx >= 0 && g.EndIdx >= 0
 }
 
+// Simple function, makes it easier to map this over a list of matches
+func getZeroGroup(m Match) Group {
+	return m[0]
+}
+
 // takeZeroState takes the 0-state (if such a transition exists) for all states in the
 // given slice. It returns the resulting states. If any of the resulting states is a 0-state,
 // the second ret val is true.
@@ -138,36 +143,58 @@ func pruneIndices(indices []Match) []Match {
 	return toRet
 }
 
-// FindString returns a string containing the text of the leftmost match of the regex in the given string.
+// Find returns the 0-group of the leftmost match of the regex in the given string.
+// An error value != nil indicates that no match was found.
+func (regex Reg) Find(str string) (Group, error) {
+	match, err := regex.FindNthMatch(str, 1)
+	if err != nil {
+		return Group{}, nil
+	}
+	return getZeroGroup(match), nil
+}
+
+// FindAll returns a slice containing all the 0-groups of the regex in the given string.
+// A 0-group represents the match without any submatches.
+func (regex Reg) FindAll(str string) []Group {
+	indices := regex.FindAllSubmatch(str)
+	zeroGroups := funcMap(indices, getZeroGroup)
+	return zeroGroups
+}
+
+// FindString returns the text of the leftmost match of the regex in the given string.
 // The return value will be an empty string in two situations:
 //  1. No match was found
 //  2. The match was an empty string
 func (regex Reg) FindString(str string) string {
-	match, err := FindNthMatch(regex, str, 1)
+	match, err := regex.FindNthMatch(str, 1)
 	if err != nil {
 		return ""
 	}
-	return str[match[0].StartIdx:match[0].EndIdx]
+	zeroGroup := getZeroGroup(match)
+	return str[zeroGroup.StartIdx:zeroGroup.EndIdx]
 }
 
 // FindAllString is the 'all' version of FindString.
 // It returns a slice of strings containing the text of all matches of
 // the regex in the given string.
-func FindAllString(regex Reg, str []string) []string {
-	return []string{}
+func (regex Reg) FindAllString(str string) []string {
+	zerogroups := regex.FindAll(str)
+	matchStrs := funcMap(zerogroups, func(g Group) string {
+		return str[g.StartIdx:g.EndIdx]
+	})
+	return matchStrs
 }
 
-// FindNthMatch finds the 'n'th match of the regex represented by the given start-state, with
-// the given string.
+// FindNthMatch return the 'n'th match of the regex in the given string.
 // It returns an error (!= nil) if there are fewer than 'n' matches in the string.
-func FindNthMatch(regex Reg, str string, n int) (Match, error) {
+func (regex Reg) FindNthMatch(str string, n int) (Match, error) {
 	idx := 0
 	matchNum := 0
 	str_runes := []rune(str)
 	var matchFound bool
 	var matchIdx Match
 	for idx <= len(str_runes) {
-		matchFound, matchIdx, idx = findAllMatchesHelper(regex.start, str_runes, idx, regex.numGroups)
+		matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups)
 		if matchFound {
 			matchNum++
 		}
@@ -179,16 +206,15 @@ func FindNthMatch(regex Reg, str string, n int) (Match, error) {
 	return nil, fmt.Errorf("invalid match index - too few matches found")
 }
 
-// FindAllMatches tries to find all matches of the regex represented by given start-state, with
-// the given string
-func FindAllMatches(regex Reg, str string) []Match {
+// FindAllSubmatch returns a slice of matches in the given string.
+func (regex Reg) FindAllSubmatch(str string) []Match {
 	idx := 0
 	str_runes := []rune(str)
 	var matchFound bool
 	var matchIdx Match
 	indices := make([]Match, 0)
 	for idx <= len(str_runes) {
-		matchFound, matchIdx, idx = findAllMatchesHelper(regex.start, str_runes, idx, regex.numGroups)
+		matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups)
 		if matchFound {
 			indices = append(indices, matchIdx)
 		}
@@ -196,6 +222,7 @@ func FindAllMatches(regex Reg, str string) []Match {
 	if len(indices) > 0 {
 		return pruneIndices(indices)
 	}
+
 	return indices
 }
 
@@ -204,7 +231,7 @@ func FindAllMatches(regex Reg, str string) []Match {
 // the next search should start from.
 //
 //	Might return duplicates or overlapping indices, so care must be taken to prune the resulting array.
-func findAllMatchesHelper(start *nfaState, str []rune, offset int, numGroups int) (bool, Match, int) {
+func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups int) (bool, Match, int) {
 	// Base case - exit if offset exceeds string's length
 	if offset > len(str) {
 		// The second value here shouldn't be used, because we should exit when the third return value is > than len(str)

regex/nfa.go

@@ -156,17 +156,18 @@ func (s nfaState) checkAssertion(str []rune, idx int) bool {
 			strToMatch = string(runesToMatch)
 		}
 
-		matchIndices := FindAllMatches(Reg{startState, s.lookaroundNumCaptureGroups}, strToMatch)
+		regComp := Reg{startState, s.lookaroundNumCaptureGroups}
+		matchIndices := regComp.FindAll(strToMatch)
 
 		numMatchesFound := 0
 		for _, matchIdx := range matchIndices {
 			if s.assert == plaAssert || s.assert == nlaAssert { // Lookahead - return true (or false) if at least one match starts at 0. Zero is used because the test-string _starts_ from idx.
-				if matchIdx[0].StartIdx == 0 {
+				if matchIdx.StartIdx == 0 {
 					numMatchesFound++
 				}
 			}
 			if s.assert == plbAssert || s.assert == nlbAssert { // Lookbehind - return true (or false) if at least one match _ends_ at the current index.
-				if matchIdx[0].EndIdx == idx {
+				if matchIdx.EndIdx == idx {
 					numMatchesFound++
 				}
 			}

regex/re_test.go

@@ -682,13 +682,9 @@ func TestFindAllMatches(t *testing.T) {
 					panic(fmt.Errorf("Test Error: %v", err))
 				}
 			} else {
-				matchIndices := FindAllMatches(regComp, test.str)
-				zeroGroups := make([]Group, len(matchIndices))
-				for i, m := range matchIndices {
-					zeroGroups[i] = m[0]
-				}
-				if !slices.Equal(test.result, zeroGroups) {
-					t.Errorf("Wanted %v	Got %v\n", test.result, zeroGroups)
+				matchIndices := regComp.FindAll(test.str)
+				if !slices.Equal(test.result, matchIndices) {
+					t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
 				}
 			}
 		})
@@ -720,6 +716,31 @@ func TestFindString(t *testing.T) {
 	}
 }
 
+func TestFindAllStrings(t *testing.T) {
+	for _, test := range reTests {
+		t.Run(test.re+"	"+test.str, func(t *testing.T) {
+			regComp, err := Compile(test.re, test.flags...)
+			if err != nil {
+				if test.result != nil {
+					panic(err)
+				}
+			} else {
+				foundStrings := regComp.FindAllString(test.str)
+				if len(test.result) != len(foundStrings) {
+					t.Errorf("Differing number of matches: Wanted %v matches Got %v matches\n", len(test.result), len(foundStrings))
+				} else {
+					for idx, group := range test.result {
+						groupStr := test.str[group.StartIdx:group.EndIdx]
+						if groupStr != foundStrings[idx] {
+							t.Errorf("Wanted %v	Got %v\n", groupStr, foundStrings[idx])
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
 func TestFindAllGroups(t *testing.T) {
 	for _, test := range groupTests {
 		t.Run(test.re+"	"+test.str, func(t *testing.T) {
@@ -729,7 +750,7 @@ func TestFindAllGroups(t *testing.T) {
 					panic(err)
 				}
 			}
-			matchIndices := FindAllMatches(regComp, test.str)
+			matchIndices := regComp.FindAllSubmatch(test.str)
 			for i := range matchIndices {
 				for j := range matchIndices[i] {
 					if matchIndices[i][j].isValid() {