Lisp 简化符号表达式_Lisp_Common Lisp

Lisp 简化符号表达式

lisp common-lisp

Lisp 简化符号表达式,lisp,common-lisp,Lisp,Common Lisp,我是Lisp新手，需要一些帮助。我需要简化下一个表达式：从（+（+ab）C）到（+ab C）从（-ab）C）到（-ab C）如果你能帮我解决其中一个问题，我会明白我需要如何解决下一个问题非常感谢。假设您有一个与此模式匹配的输入，（+e1…en），您希望递归地将所有e1简化为en，这将为您提供s1，…，sn，然后提取以+开头的所有si，将其参数上移一级，到您正在构建的简化表达式表达式e与上述模式匹配，如果（and（consp e）（eq'+（care））然后，所有的ei仅由（cdr

我是Lisp新手，需要一些帮助。我需要简化下一个表达式：从

（+（+ab）C）

到

（+ab C）

从

（-ab）C）

到

（-ab C）

如果你能帮我解决其中一个问题，我会明白我需要如何解决下一个问题

非常感谢。

假设您有一个与此模式匹配的输入，

（+e1…en）

，您希望递归地将所有

e1

简化为

en

，这将为您提供

s1

，…，

sn

，然后提取以

开头的所有

si

，将其参数上移一级，到您正在构建的简化表达式

表达式

与上述模式匹配，如果

（and（consp e）（eq'+（care））

然后，所有的
```
ei
```
仅由
```
（cdre）
```
列表给出
以
```
（+）
```
为例，如何简化它
要将函数
```
f
```
应用于值列表，请调用
```
（mapcar#f list）
```

要根据谓词

将列表拆分为两个列表，可以使用循环：

(let ((sat nil) (unsat nil))
  (dolist (x list (values sat unsat))
    (if (funcall predicate x) 
        (push x sat) 
        (push x unsat))))

有一种纯粹的功能性方法来写这个，你能理解吗

(define/match (simplify expression)
  ;; simplifier driver
  (((cons op args))
   ;; An operator with some arguments
   ;; Note that this assumes that the arguments to operators are always
   ;; expressions to simplify, so the recursive level can be here
   (simplify-op op (map simplify args)))
  ((expr)
   ;; anything else
   expr))

(define op-table (make-hash))

(define-syntax-rule (define-op-simplifier (op args) form ...)
  ;; Define a simplifier for op with arguments args
  (hash-set! op-table 'op (λ (args) form ...)))

(define (simplify-op op args)
  ;; Note the slightly arcane fallback: you need to wrap it in a thunk
  ;; so hash-ref does not try to call it.
  ((hash-ref op-table op (thunk (λ (args) (cons op args)))) args))

(define-op-simplifier (+ exprs)
  ;; Simplify (+ ...) by flattening + in its arguments
  (let loop ([ftail exprs]
             [results '()])
    (if (null? ftail)
        `(+ ,@(reverse results))
        (loop (rest ftail)
              (match (first ftail)
                [(cons '+ addends)
                 (append (reverse addends) results)]
                [expr (cons expr results)])))))

（+123A4）

（+6 a 4）

（+10 a）

(define (coalesce-literal-numbers f elts)
  ;; coalesce runs of literal numbers for an operator f.
  ;; This relies on the fact that (f) returns a good identity for f
  ;; (so in particular it returns an exact number).  Thisis true for Racket
  ;; and CL and I think any Lisp worth its salt.
  ;;
  ;; Note that it's important here that (eqv? 1 1.0) is false.
  ;;;
  (define id (f))
  (let loop ([tail elts]
             [accum id]
             [results '()])
    (cond [(null? tail)
           (if (not (eqv? accum id))
               (reverse (cons accum results))
               (reverse results))]
          [(number? (first tail))
           (loop (rest tail)
                 (f accum (first tail))
                 results)]
          [(eqv? accum id)
           (loop (rest tail)
                 accum
                 (cons (first tail) results))]
          [else
           (loop (rest tail)
                 id
                 (list* (first tail) accum results))])))

（+x）

(define-op-simplifier (+ exprs)
  ;; Simplify (+ ...) by flattening + in its arguments
  (let loop ([ftail exprs]
             [results '()])
    (if (null? ftail)
        (let ([coalesced (coalesce-literal-numbers + (reverse results))])
          (match coalesced
            [(list something)
             something]
            [exprs
             `(+ ,@exprs)]))
        (loop (rest ftail)
              (match (first ftail)
                [(cons '+ addends)
                 (append (reverse addends) results)]
                [expr (cons expr results)])))))

> (simplify 'a)
'a
> (simplify 1)
1
> (simplify '(+ 1 a))
'(+ 1 a)
> (simplify '(+ a (+ b c)))
'(+ a b c)
> (simplify '(+ 1 (+ 3 c) 4))
'(+ 4 c 4)
> (simplify '(+ 1 2 3))
6

(define (simplify-arith-op op fn exprs)
  (let loop ([ftail exprs]
             [results '()])
    (if (null? ftail)
        (let ([coalesced (coalesce-literal-numbers fn (reverse results))])
          (match coalesced
            [(list something)
             something]
            ['()
             (fn)]
            [exprs
             `(,op ,@exprs)]))
        (loop (rest ftail)
              (match (first ftail)
                [(cons the-op addends)
                 #:when (eqv? the-op op)
                 (append (reverse addends) results)]
                [expr (cons expr results)])))))

(define-op-simplifier (+ exprs)
  (simplify-arith-op '+ + exprs))

(define-op-simplifier (* exprs)
  (simplify-arith-op '* * exprs))

(simplify '(+ a (* 1 2 (+ 4 5)) (* 3 4) 6 (* b)))
'(+ a 36 b)

（*1A1B）

（*AB）

（*1A1B）