Lisp中的替换功能重复了Mathematica功能

Question

在Mathematica克隆或任何版本的Lisp中实现最简单的方法是什么（实际上甚至Haskell都可以用任何一种语言）？ 似乎没有任何lisps 具有类似的replace功能 。

Replace[{
  f[{x, "[", y, "]"}],
  f@f[{x, "[", y, y2, "]"}]
  }
 , f[{x_, "[", y__, "]"}] :> x[y],
 Infinity]

返回值为{x[y], f[x[y, y2]]}

它替换了args中f[{x_, "[", y__, "]"}]所有实例，其中x_代表单个变量，而y__代表一个或多个变量。

在Lisp中，功能和替换可能是等效的（原谅我在Lisp中不是最好的）。 我在寻找表单的功能(replace list search replace) 。

(replace
  '(
   (f (x "[" y "]"))
   (f (f '(x "[" y y2 "]")))
  )
  '(f (x_ "[" y__ "]"))
  '(x y)
)

并获得返回值[ ((xy) (f (xy y2))) 。

Answer 1

让我们再试一次。

首先，安装quicklisp并将其用于获取，安装和加载optima和alexandria 。

(ql:quickload :optima)
(ql:quickload :alexandria)
(use-package :alexandria)

下面引用的alexandria函数为alexandria ensure-list和last-elt 。 如果未安装它们，则可以使用以下定义：

(defun ensure-list (list) (if (listp list) list (list list)))
(defun last-elt (list) (car (last list)))

我们将规则定义为从一种形式到另一种形式的功能。 下面，该函数尝试将输入解构为(f (<X> "[" <ARGS> "]") ，其中<ARGS>为零或更多形式。如果解构失败，则返回NIL （我们期望不匹配）过滤器以返回NIL ）。

(defun match-ugly-funcall (form)
  (optima:match form
    ((list 'f (cons x args))
     (unless (and (string= "[" (first args))
                  (string= "]" (last-elt args)))
       (optima:fail))
     `(,x ,@(cdr (butlast args))))))

(match-ugly-funcall '(f (g "[" 1 3 5 4 8 "]")))
; => (G 1 3 5 4 8)

然后，我们使用此函数模拟Mathematica的Replace，该函数采用一种形式和要尝试的规则列表。 可以传递一个规则（感谢ensure-list ）。 如果给出了规则列表，则应返回一个匹配列表（完成）。

(defun match-replace (form rules &optional (levelspec '(0)))
  (setf rules (ensure-list rules))
  (multiple-value-bind (match-levelspec-p recurse-levelspec-p)
      (optima:ematch levelspec
        ((list n1 n2) (if (some #'minusp (list  n1 n2))
                          (optima:fail)
                          (values (lambda (d) (<= n1 d n2))
                                  (lambda (d) (< d n2)))))
        ((list n) (if (minusp n)
                      (optima:fail)
                      (values (lambda (d) (= d n))
                              (lambda (d) (< d n)))))
        (:infinity (values (constantly t) (constantly t))))
    (labels
        ((do-replace (form depth)
           (let ((result
                   (and (funcall match-levelspec-p depth)
                        (some (lambda (r) (funcall r form)) rules))))
             (cond
               (result (values result t))
               ((and (listp form)
                     (funcall recurse-levelspec-p depth))
                (incf depth)
                (do (newlist
                     (e (pop form) (pop form)))
                    ((endp form) (values form nil))
                  (multiple-value-bind (result matchedp) (do-replace e depth)
                    (if matchedp
                        (return (values (nconc (nreverse newlist) 
                                               (list* result form)) t))
                        (push e newlist)))))
               (t (values form nil))))))
      (do-replace form 0))))

并进行测试：

(match-replace '(a b (f (x "[" 1 2 3 "]")) c d)
               #'match-ugly-funcall
               :infinity)
; => (A B (X 1 2 3) C D)
;    T

为了替换所有表达式而不是第一个匹配表达式，请改用以下表达式：

  (defun match-replace-all (form rules &optional (levelspec '(0)))
      (setf rules (ensure-list rules))
      (multiple-value-bind (match-levelspec-p recurse-levelspec-p)
          (optima:ematch levelspec
            ((list n1 n2) (if (some #'minusp (list  n1 n2))
                              (optima:fail)
                              (values (lambda (d) (<= n1 d n2))
                                      (lambda (d) (< d n2)))))
            ((list n) (if (minusp n)
                          (optima:fail)
                          (values (lambda (d) (= d n))
                                  (lambda (d) (< d n)))))
            (:infinity (values (constantly t) (constantly t))))
        (labels
            ((do-replace (form depth)
               (let ((result
                       (and (funcall match-levelspec-p depth)
                            (some (lambda (r) (funcall r form)) rules))))
                 (cond
                   (result result)
                   ((and (listp form)
                         (funcall recurse-levelspec-p depth))
                    (incf depth)
                    (mapcar (lambda (e) (do-replace e depth)) form))
                   (t form)))))
          (do-replace form 0))))

Answer 2

哦，天哪，Mathematica如何运用其著名的NIH方法设法使所有事物变得模糊。

基本上，您正在寻找一种根据某种模式执行字符串替换的函数。 在大多数语言中，这是通过正则表达式完成的。

例如，在使用cl-ppcre库的Common Lisp中，它将看起来像这样：

(cl-ppcre:regex-replace-all
 ;; regular expression you match against with groups
 "f\\[{(x[^ ]*), \"\\[\", ((y[^ ]* ?)+), \"\\]\"}\\]"
 ;; your string
 "{f[{x, \"[\", y, \"]\"}], f@f[{x, \"[\", y, y2, \"]\"}]}"
 ;; substitution expression using groups 1 & 2 
 "\\1[\\2]")

当然，您可以编写一个专用的20行函数来解决使用subst和recursion匹配和替换子树的问题，但是，如果您想要的只是与所介绍的情况相似的情况，则可以采用基于正则表达式的简单方法。