(library (bs re (0))

  ;; Similar to Python's `re` module. One big difference is that the
  ;; string object to be searched is always the first argument to a
  ;; function. This allows us to pipe a string through multiple
  ;; transformations. For example:
  ;;
  ;; (-> " string "
  ;;     string.strip
  ;;     (re.search "in")
  ;;     (re.group 1))
  ;;
  ;; TODO: consider putting the string as the last argument, to fit with
  ;; other container types like `list`, then use ->>
  ;; TODO: port srfi-115 to guile
  ;; TODO: make `match` and `search` do different things

  (export match group sub search compile
          ;; I IGNORECASE M MULTILINE
          )
  (import (rnrs base)
          ;; TODO: port to srfi-115
          (ice-9 regex))

  ;; (define I regexp/icase)
  ;; (define IGNORECASE regexp/icase)
  ;; (define M regexp/newline)
  ;; (define MULTILINE regexp/newline)

  ;; Compile `pattern` into a regular expression object.
  (define (compile pattern . flags)
    (apply make-regexp (cons pattern flags)))

  ;; If zero or more characters at the beginning of `string` match the
  ;; regular expression `pattern`, return a corresponding match object.
  (define (match string pattern)
    (regexp-exec pattern string))

  ;;
  (define (group match-obj n)
    (if match-obj
        (match:substring match-obj n)
        #f))

  ;; Return the string obtained by replacing the leftmost
  ;; non-overlapping occurrences of `pattern` in `string` by the
  ;; replacement `repl`. If the pattern isn’t found, string is returned
  ;; unchanged.
  (define (sub string pattern repl)
    (regexp-replace pattern string repl))

  ;; Scan through `string` looking for the first location where the
  ;; regular expression `pattern` produces a match, and return a
  ;; corresponding match object. Returns `#f` if no match is found.
  (define (search string pattern)
    (regexp-exec pattern string)))