Obtenga todas las coincidencias regexp en el búfer como una lista

En el sitio de Code Golf Stack Exchange hoy, encontré esta respuesta en Clojure a la pregunta "Obtener todos los enlaces en una página web".

(->> (slurp "http://www.stroustrup.com")
     (re-seq #"(?:http://)?www(?:[./#\+-]\w*)+"))

Sin la macro elegante, es solo esto:

(re-seq #"(?:http://)?www(?:[./#\+-]\w*)+" (slurp "http://www.stroustrup.com"))

Esto devuelve la lista:

("http://www.morganstanley.com/" "http://www.cs.columbia.edu/" "http://www.cse.tamu.edu" ...)

¿Puedo hacer algo similar en Emacs Lisp?

Tal vez una función como (re-seq regexp (buffer-string))esa regresa '(firstmatch secondmatch thirdmatch ...)?

Así es como puede hacerlo en función de las cadenas, según lo solicitado.

(defun re-seq (regexp string)
  "Get a list of all regexp matches in a string"
  (save-match-data
    (let ((pos 0)
          matches)
      (while (string-match regexp string pos)
        (push (match-string 0 string) matches)
        (setq pos (match-end 0)))
      matches)))

; Sample URL
(setq urlreg "\\(?:http://\\)?www\\(?:[./#\+-]\\w*\\)+")
; Sample invocation
(re-seq urlreg (buffer-string))

Probablemente valga la pena señalar que invocar occurcon el argumento universal hace que llene el *Occur*búfer solo con coincidencias, sin nombres de archivo, números de línea o información de encabezado. Cuando se combina con un grupo de captura, esto permite extraer el patrón que se desee.

Por ejemplo, C-u M-x occurseguido de \"\(.*\)\"preguntará al usuario qué grupo de captura debe recopilar (predeterminado \1) y luego colocará el contenido de cada cadena citada en el *Occur*búfer.

Tengo una respuesta de emacs lisp a esa pregunta publicada: /codegolf//a/44319/18848

Usando la misma estructura (while (search) (print)) podría modificarla en una función para insertar coincidencias en un búfer en una lista y devolverla así:

(defun matches-in-buffer (regexp &optional buffer)
  "return a list of matches of REGEXP in BUFFER or the current buffer if not given."
  (let ((matches))
    (save-match-data
      (save-excursion
        (with-current-buffer (or buffer (current-buffer))
          (save-restriction
            (widen)
            (goto-char 1)
            (while (search-forward-regexp regexp nil t 1)
              (push (match-string 0) matches)))))
      matches)))

Usar s.elesto hubiera sido más corto, pero, desafortunadamente, da demasiadas coincidencias:

(defun all-urls-in-buffer ()
  (s-match-strings-all
   "\\(?:http://\\)?www\\(?:[./#+-]\\w*\\)+"
   (buffer-string)))

Si esto está bien (la expresión regular para las URL no es perfecta de todos modos), esto podría ser más corto, y si no, entonces no creo que pueda hacerlo más corto que la respuesta de Alan Shutko.

Permítanme mencionar por qué creo que esto no se implementa en el núcleo. Simplemente por razones de eficiencia: no hay necesidad de copiar, crear listas, pasarlas y recolectar basura. En su lugar, almacene la cadena completa como el búfer y opere con límites de coincidencia de enteros. Así es como occurfunciona, por ejemplo: coincide con una cadena a la vez e inserta la coincidencia *occur*. No coincide con todas las cadenas a la vez, hacerlas en la lista, hacer un bucle en la lista para insertar *occur*y recolectar basura de la lista y sus cadenas.

Al igual que no escribirías (do (def x 1) (def x (+ 2 x)))en Clojure, por defecto no deberías intentar que Elisp se comporte como un lenguaje funcional. Me encantaría si lo fuera, pero tenemos que cumplir con lo que tenemos en este momento.

Si se me permite un enchufe, eche un vistazo a mi biblioteca "m-buffer".

(m-buffer-match buffer "foo")

Devuelve una lista de marcadores con los que coincide foo.