Add regex functions to core (#193)

Author: chrisrink10

basilisp/core/__init__.lpy

@@ -1274,3 +1274,61 @@
        (in-ns (quote ~name))
        ~requires
        ~@imports)))
+
+;;;;;;;;;;;;;;;;;;;;;
+;; Regex Functions ;;
+;;;;;;;;;;;;;;;;;;;;;
+
+(import re)
+
+(defn re-pattern
+  "Return a new re.Pattern instance."
+  [s]
+  (re/compile s))
+
+(defn re-find
+  "Returns the first match of a string to a pattern using re.search.
+
+  If the string matches the pattern exactly and there are no match
+  groups, return the string. Otherwise, return a vector with the string
+  in the first position and the match groups in the following positions."
+  [pattern s]
+  (let [match (re/search pattern s)]
+    (when match
+      (let [groups (.groups match)]
+        (if (zero? (count groups))
+          (.group match 0)
+          (vec (cons (.group match 0) groups)))))))
+
+(defn re-matches
+  "Returns a match of a string to a pattern using re.fullmatch.
+
+  If the string matches the pattern exactly and there are no match
+  groups, return the string. Otherwise, return a vector with the string
+  in the first position and the match groups in the following positions."
+  [pattern s]
+  (let [match (re/fullmatch pattern s)]
+    (when match
+      (let [groups (.groups match)]
+        (if (zero? (count groups))
+          (.group match 0)
+          (vec (cons (.group match 0) groups)))))))
+
+(defn ^:private lazy-re-seq
+  "Return a lazy sequence of the matches in a match iterator."
+  [iter]
+  (lazy-seq
+   (when (first iter)
+     (let [match (.group (first iter) 0)]
+       (cons match (when (seq (rest iter))
+                     (lazy-re-seq (rest iter))))))))
+
+(defn re-seq
+  "Returns a lazy sequence of matches of a string to a pattern using re.finditer.
+
+  If the string matches the pattern exactly and there are no match
+  groups, return the string. Otherwise, return a vector with the string
+  in the first position and the match groups in the following positions."
+  [pattern s]
+  (lazy-re-seq (seq (re/finditer pattern s))))
+

tests/core_test.py

@@ -1,4 +1,5 @@
 import itertools
+import re
 from fractions import Fraction
 from unittest.mock import Mock
 
@@ -610,3 +611,26 @@ def test_merge():
     assert lmap.map({kw.keyword("a"): 53, kw.keyword("b"): "hi"}) == core.merge(
         lmap.map({kw.keyword("a"): 1, kw.keyword("b"): "hi"}),
         lmap.map({kw.keyword("a"): 53}))
+
+
+def test_re_find():
+    assert None is core.re_find(re.compile(r"\d+"), "abcdef")
+    assert "12345" == core.re_find(re.compile(r"\d+"), "abc12345def")
+    assert vec.v("word then number ", "word then number ", None) == core.re_find(
+        re.compile(r"(\D+)|(\d+)"), "word then number 57")
+    assert vec.v("57", None, "57") == core.re_find(
+        re.compile(r"(\D+)|(\d+)"), "57 number then word")
+    assert vec.v("lots", "", "l") == core.re_find(re.compile(r"(\d*)(\S)\S+"), "lots o' digits 123456789")
+
+
+def test_re_matches():
+    assert None is core.re_matches(re.compile(r"hello"), "hello, world")
+    assert "hello, world" == core.re_matches(re.compile(r"hello.*"), "hello, world")
+    assert vec.v("hello, world", "world") == core.re_matches(re.compile(r"hello, (.*)"), "hello, world")
+
+
+def test_re_seq():
+    assert None is core.seq(core.re_seq(re.compile(r"[a-zA-Z]+"), "134325235234"))
+    assert llist.l("1", "1", "0") == core.re_seq(re.compile(r"\d+"), "Basilisp 1.1.0")
+    assert llist.l("the", "man", "who", "sold", "the", "world") == core.re_seq(
+        re.compile(r"\w+"), "the man who sold the world")