1

该程序应重新格式化字符串，如下所示。

示例：（game-print '（这是一个句子。关于这个？可能。））

这是一个句子。那个呢？大概。

但是出了点问题（Lisp 嵌套超过了 `max-lisp-eval-depth），我不知道为什么。这段代码其实是出自《Land of lisp》一书97页。原始代码是用common lisp写的。我想用elisp重写它。调整文本中的最后两个参数表示船长和文字。

(defun tweak-text (lst caps lit)
  (when lst
    (let ((item (car lst))
          (rest (cdr lst)))
      (cond ((eql item ?\ ) (cons item (tweak-text rest caps lit)))
            ((member item '(?\! ?\? ?\.)) (cons item (tweak-text rest t lit)))
            ((eql item ?\") (tweak-text rest caps (not lit)))
            (lit (cons item (tweak-text rest nil lit)))
            (caps (cons (upcase item) (tweak-text rest nil lit)))
            (t (cons (downcase item) (tweak-text rest nil nil)))))))

(defun game-print (lst)
  (print (coerce (tweak-text (coerce (prin1-to-string lst) 'list) t nil) 'string)))

(game-print '(not only does this sentence have a "comma," it also mentions the "iPad."))

用 common lisp 编写的原始代码。

(defun tweak-text (lst caps lit)
  (when lst
    (let ((item (car lst))
          (rest (cdr lst)))
      (cond ((eql item #\space) (cons item (tweak-text rest caps lit)))
            ((member item '(#\! #\? #\.)) (cons item (tweak-text rest t lit)))
            ((eql item #\") (tweak-text rest caps (not lit)))
            (lit (cons item (tweak-text rest nil lit)))
            (caps (cons (char-upcase item) (tweak-text rest nil lit)))
            (t (cons (char-downcase item) (tweak-text rest nil nil)))))))

(defun game-print (lst)
    (princ (coerce (tweak-text (coerce (string-trim "() " (prin1-to-string lst)) 'list) t nil) 'string))
    (fresh-line))
4

5 回答 5

4

在这两种情况下，您都有非终端递归，因此您使用的是 O(length(lst)) 堆栈空间。显然，系统可能会限制您可以使用的堆栈空间，而您确实在 emacs 中达到了这个限制。（现在在 emacs 中，您可以通过更改 max-lisp-eval-depth 来增加限制，但这不会解决根本问题）。

解决方案是使用迭代而不是递归。

但首先，在 emacs 中编写：

(defun character (x)
  "common-lisp: return the character designated by X."
  (etypecase x
    (integer x)
    (string (aref x 0))
    (symbol (aref (symbol-name x) 0))))

(defun string-trim (character-bag string-designator)
  "common-lisp: returns a substring of string, with all characters in \
character-bag stripped off the beginning and end."
  (unless (sequencep character-bag)
    (signal 'type-error  "expected a sequence for `character-bag'."))
  (let* ((string (string* string-designator))
         (margin (format "[%s]*" (regexp-quote
                                  (if (stringp character-bag)
                                      character-bag
                                      (map 'string 'identity character-bag)))))
         (trimer (format "\\`%s\\(\\(.\\|\n\\)*?\\)%s\\'" margin margin)))
    (replace-regexp-in-string  trimer "\\1" string)))

(require 'cl)

这样您就可以为 CL 和 elisp 编写一个函数：

(defun tweak-text (list caps lit)
  (let ((result '()))
    (dolist (item list (nreverse result))
      (cond ((find item " !?.")          (push item result))
            ((eql item (character "\"")) (setf lit (not lit)))
            (lit                         (push item result)
                                         (setf caps nil))
            (caps                        (push (char-upcase item) result)
                                         (setf caps nil))
            (t                           (push (char-downcase item) result)
                                         (setf caps nil
                                               lit nil))))))

(defun game-print (list)
  (princ (coerce (tweak-text (coerce (string-trim "() " (prin1-to-string list)) 'list)
                             t nil)
                 'string))
  (terpri))

然后：

(game-print '(not only does this sentence have a "comma," it also mentions the "iPad."))

在 emacs 中：

prints:   Not only does this sentence have a comma, it also mentions the iPad.
returns:  t

在 Common Lisp 中：

prints:   Not only does this sentence have a comma, it also mentions the iPad.
returns:  nil

现在，通常使用列表来处理字符串没有什么意义，emacs lisp 和 Common Lisp 都有强大的原语来直接处理序列和字符串。

于 2012-06-14T05:07:09.060 回答
3

请注意，elisp（遗憾的是）没有针对尾递归进行优化，因此事实证明这是编写此函数的一种非常低效的方式。

于 2012-06-14T04:27:10.423 回答
1

在调整文本中递归时，您确实达到了“max-lisp-eval-depth”限制。我看不出代码的方式有什么问题（我没有检查它是否在做你想做的事情）。

您可以配置/提高“max-lisp-eval-depth”限制。该变量的文档指出，只要您确信自己不会遇到堆栈空间不足的情况，就可以提高它。我的机器上的限制保守地设置为 541。将其提高到 600 使上面的函数定义可以处理您作为示例提供的输入。

于 2012-06-14T03:30:54.243 回答
1

正如 Pascal Bourguignon 已经提到的那样，使用不强制它们到列表并返回的字符串是一种更好的方法，下面是我的看法。请注意，在验证文字字符串是否有标点符号方面略有不同，如果它们看起来有标点符号，否则会导致下一个字母大写，那么它也会大写。我不确定这是一个缺点，这就是我没有处理这种差异的原因。

(defun tweak-text (source)
  (let ((i 0) (separator "") (cap t) current)
    (with-output-to-string
      (dolist (i source)
        (setq current
              (concat separator 
                      (etypecase i
                        (string i)
                        (symbol (downcase (symbol-name i)))))
              separator " ")
        (let (current-char)
          (dotimes (j (length current))
            (setq current-char (aref current j))
            (cond
             ((position current-char " \t\n\r"))
             (cap (setq cap nil
                        current-char (upcase current-char)))
             ((position current-char ".?!")
              (setq cap t)))
            (princ (char-to-string current-char))))))))

(tweak-text '(not only does this sentence have a "comma," it also mentions the "iPad."))
"Not only does this sentence have a comma, it also mentions the iPad."
于 2012-06-16T08:37:52.003 回答
0

我认为你应该写这样的东西：

(defun tweak-text-wrapper (&rest args)
  (let ((max-lisp-eval-depth 9001)) ; as much as you want
    (apply tweak-text args)))
于 2012-06-14T04:34:42.367 回答