计算机程序的构造和解释的笔记(69)

按有用程度 按页码先后 最新笔记

• 

  第1页

  追忆似风 (工欲善其事,必先利其器~)

  读书笔记 第一章题解~ http://www.freopen.com/?p=10382 第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385 第三章已经看完了,不过最近比较忙,练习需要等等再写~ P.S. 建了一个"计算机科学"的QQ群:20076724~欢迎加入!~ 很欢乐的写了一个C++版的解释器,各种泄漏内存.可以深入探讨一下,如果不存在赋值语句,应该可以保证永远不存在环结构,从而使用计数器来管理内存. (更多)

  读书笔记

  第一章题解~ http://www.freopen.com/?p=10382

  第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385

  第三章已经看完了,不过最近比较忙,练习需要等等再写~

  P.S.

  建了一个"计算机科学"的QQ群:20076724~欢迎加入!~

  很欢乐的写了一个C++版的解释器,各种泄漏内存.可以深入探讨一下,如果不存在赋值语句,应该可以保证永远不存在环结构,从而使用计数器来管理内存. (收起)

  2011-04-05 04:40:34   4回应

  收藏

  推荐
• 

  第189页

  huangz (El Psy Congroo)

  勘误，第一段的最后一行： 『也就是说，当且仅当一个或门的两个输入信号之一为 1 时，其输出为 1 ，否则其输出就是 0 。』 原文（http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-22.html#%_sec_3.3.4）： 『That is, the output will become 1 if at least one of the input signals is 1; otherwise the output will become 0.』 这里译者将 OR 的意思译成了 XOR 的意思了，正确翻译应该是： 『。。。如果... (更多)

  勘误，第一段的最后一行：

  『也就是说，当且仅当一个或门的两个输入信号之一为 1 时，其输出为 1 ，否则其输出就是 0 。』

  原文（http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-22.html#%_sec_3.3.4）：

  『That is, the output will become 1 if at least one of the input signals is 1; otherwise the output will become 0.』

  这里译者将 OR 的意思译成了 XOR 的意思了，正确翻译应该是：

  『。。。如果至少有一个输入信号为 1 ，那么输出为 1 ；否则。。。』 (收起)

  2012-05-15 09:59:03   2人收藏   4回应

  收藏

  推荐
• 

  二， 数据抽象 church numerals

  老徐

  现在到了数学抽象中最关键的一步：让我们忘记这些符号所表示的对象。(数学家）不应在这里停步，有许多操作可以应用于这些符号，而根本不必考虑它们到底代表着什么东西。 邱奇数可以帮我们充分理解上面这句话和数据抽象的含义。 /代码内容已省略/ 邱奇数可以很好的将数学计算，用符号演算构造出来，并得到所有（可计算的）“自然数”（符号）。（将操作应用于符号，而不必考虑他们... (更多)

  现在到了数学抽象中最关键的一步：让我们忘记这些符号所表示的对象。(数学家）不应在这里停步，有许多操作可以应用于这些符号，而根本不必考虑它们到底代表着什么东西。

  邱奇数可以帮我们充分理解上面这句话和数据抽象的含义。

  (define (inc n)
    (+ n 1))
  (define zero
    (lambda (f zero)
      zero))
  (define one
    (lambda (f zero)
      (f zero)))
  (define two
    (lambda (f zero)
      (f (f zero))))
  
  (define (add x y)
    (lambda (f zero)
      (x f (y f zero))))
  
  
  (define three (add two one))
  
  ;; 3+3
  (define (multiply x y)
    (lambda (f zero)
      (x (lambda (z)
           (y f z))
         zero)))
  
  (define four (multiply two three))
  (four inc 0)
  

  邱奇数可以很好的将数学计算，用符号演算构造出来，并得到所有（可计算的）“自然数”（符号）。（将操作应用于符号，而不必考虑他们到底代表什么东西）

  其实邱奇的lambda calculus建立一个强大的符号演算系统，利用这个（抽象）符号操作概念可以建立一个强大的形式语言，从而实现一个图灵等价的计算模型。符号演算可以模拟出数学世界里的所有计算模型，而数学计算只是这个形式语言的其中一个具体罢了。

  关于邱奇-图灵理论，停机问题，Y 组合子，不完备性定理，可以参考一下2篇好文：

  http://blog.csdn.net/pongba/article/details/1336028 http://blog.csdn.net/pongba/article/details/621723 (收起)

  2012-02-28 17:06:43   1人收藏   回应

  收藏

  推荐
• 

  第27页

  拜拜了朱亭亭 (仙风道骨)

  /代码内容已省略/ 考虑到 1美分可以为任意数目的金钱换零 所以 当最后只剩 1美分一种硬币的时候 就不用再递归了 PS 想了半天 如何用迭代的方式重写 想不出来 Lisp学龄2天 太勉强 (更多)

  (define (count-change amount)
    (cc amount 4))
  (define (cc amount kinds-of-coins)
    (cond ((and (> amount 0) (= kinds-of-coins 0)) 1)
          ((and (= amount 0) (= kinds-of-coins 0)) 1)
          ((or  (< amount 0) (= kinds-of-coins 0)) 0)
          (else (+ (cc amount
                       (- kinds-of-coins 1))
                   (cc (- amount
                          (first-denomination kinds-of-coins))
                       kinds-of-coins)))))
  (define (first-denomination kinds-of-coins)
    (cond ((= kinds-of-coins 1) 5)
          ((= kinds-of-coins 2) 10)
          ((= kinds-of-coins 3) 25)
          ((= kinds-of-coins 4) 50)))
  

  考虑到 1美分可以为任意数目的金钱换零

  所以 当最后只剩 1美分一种硬币的时候 就不用再递归了

  PS 想了半天 如何用迭代的方式重写 想不出来 Lisp学龄2天 太勉强 (收起)

  2012-06-03 23:34:15   1人收藏   5回应

  收藏

  推荐
• 

  第29页

  huangz (El Psy Congroo)

  

  练习 1.14 ，大图杀猫： (更多)

  练习 1.14 ，大图杀猫：

  
  

  (收起)

  2012-05-26 18:35:39   1人收藏   回应

  收藏

  推荐
• 

  第1页

  逆鳞 (考拉的一生也是很壮绝的！aaa)

  /代码内容已省略/ (更多)

  square = lambda x: x ** 2
  incr = lambda x: x + 1 
  double = lambda x: x * 2 
  
  def do_things_1(x, func_list):
      return reduce(lambda x, func: func(x), func_list, x)
  
  >>>print do_things_1(3, [square, incr, double])
  20
  

  (收起)

  2012-05-15 19:01:46   1人收藏   1回应

  收藏

  推荐
• 

  第193页

  huangz (El Psy Congroo)

  勘误，脚注 155 ： 『。。。例如，在写 (wire get-signal) 时，我们。。。』 原文： 『。。。For example, if we write (wire 'get-signal) we think 。。。』 这里的代码少了 ' 号。 (更多)

  勘误，脚注 155 ：

  『。。。例如，在写 (wire get-signal) 时，我们。。。』

  原文：

  『。。。For example, if we write (wire 'get-signal) we think 。。。』

  这里的代码少了 ' 号。 (收起)

  2012-05-15 17:14:23   1人收藏   回应

  收藏

  推荐
• 

  第219页

  fleuria论文叔 (Introspection)

  并发的基本现象是共享状态在不同进程间的同步，或迫使进程间通信所产生的事件按照某种特定的顺序进行；从本质上看，在并发控制中，任何时间概念都必然与通信有内在的联系；有意思的是，时间与通信之间的这种联系也出现在相对论里，在那里的光速（可能用于同步事件的最快信号）是与时间和空间有关的基本常量；在处理时间和状态时，我们在计算模型领域所遭遇的复杂性，事实上可能就是物理世界中最基本的复杂性的一种反映。 就... (更多)

  并发的基本现象是共享状态在不同进程间的同步，或迫使进程间通信所产生的事件按照某种特定的顺序进行；从本质上看，在并发控制中，任何时间概念都必然与通信有内在的联系；有意思的是，时间与通信之间的这种联系也出现在相对论里，在那里的光速（可能用于同步事件的最快信号）是与时间和空间有关的基本常量；在处理时间和状态时，我们在计算模型领域所遭遇的复杂性，事实上可能就是物理世界中最基本的复杂性的一种反映。

  就现实问题而言，社会、经济、计算机等等，最难的都是资源分配。 (收起)

  2012-04-08 20:10:36   1人收藏   2回应

  收藏

  推荐
• 

  第271页

  硅胶鱼 (才没有拖延症!人家只是惰性求值!)

  练习4.19 这道练习涉及到internal definitions的机制问题 下面的注解230说“MIT的Scheme实现支持Alyssa……”事实上，所有遵循R5RS的Scheme实现都是这样做的。R5RS(http://schemers.org/Documents/Standards/R5RS/r5rs.pdf)5.2.2.里： A <body> containing internal denitions can always be converted into a completely equivalent letrec expression (更多)

  练习4.19

  这道练习涉及到internal definitions的机制问题

  下面的注解230说“MIT的Scheme实现支持Alyssa……”事实上，所有遵循R5RS的Scheme实现都是这样做的。R5RS(http://schemers.org/Documents/Standards/R5RS/r5rs.pdf)5.2.2.里：

  A <body> containing internal denitions can always be converted into a completely equivalent letrec expression

  (收起)

  2012-01-23 11:44:56   回应

  收藏

  推荐
• 

  3.3 数字电路模拟器

  老徐

  

  此节用2个例子： 数字电路半加器为例子和约束系统（温度转换）器为例，展示了具有内部状态的计算对象作为模拟工具的威力。写出了原文代码和练习题如下： 1. 半加器实现代码（用gliffy工具画图） 图解：T开通的代表delaytime, A开头的代表action; /代码内容已省略/ 2. 约束系统 /代码内容已省略/ (更多)

  此节用2个例子： 数字电路半加器为例子和约束系统（温度转换）器为例，展示了具有内部状态的计算对象作为模拟工具的威力。写出了原文代码和练习题如下：

  1. 半加器实现代码（用gliffy工具画图）

  
  （图）agenda的数据结构

  图解：T开通的代表delaytime, A开头的代表action;

  #lang scheme
  (require r5rs)
  ;; queue 
  (define (front-ptr queue) (car queue))
  (define (rear-ptr queue) (cdr queue))
  (define (set-front-ptr! queue item) (set-car! queue item))
  (define (set-rear-ptr! queue item) (set-cdr! queue item))
  (define (empty-queue? queue) (null? (front-ptr queue)))
  (define (make-queue) (cons '() '()))
  (define (front-queue queue)
    (if (empty-queue? queue)
        (error "FRONT called with an empty queue")
        (car (front-ptr queue))))
  (define (insert-queue! queue item)
    (let ((new-pair (cons item '())))
      (cond ((empty-queue? queue)
             (set-front-ptr! queue new-pair)
             (set-rear-ptr! queue new-pair)
             queue)
            (else
             (set-cdr! (rear-ptr queue) new-pair)
             (set-rear-ptr! queue new-pair)
             queue))))
  (define (delete-queue! queue)
    (cond ((empty-queue? queue)
           (error "DELETE! called with empty queue" queue))
          (else
           (set-front-ptr! queue (cdr (front-ptr queue)))
           queue)))
  
  (define (inverter input output)
    (define (invert-input)
      (let ((new-value (logical-not (get-signal input))))
        (after-delay inverter-delay
                     (lambda ()
                       (set-signal! output new-value)))))
    (add-action! input invert-input)
    'ok)
  (define (logical-not s)
    (cond ((= s 1) 0)
          ((= s 0) 1)
          (else (error "Invalid signal" s))))
  (define (logical-and s1 s2)
    (cond ((and (= s1 1) (= s2 1)) 1)
          (else 0)))
  (define (logical-or s1 s2)
    (or s1 s2))
  
  (define (and-gate a1 a2 output)
    (define (and-action-procedure)
      (let ((new-value
             (logical-and (get-signal a1) (get-signal a2))))
        (after-delay and-gate-delay
                     (lambda ()
                       (set-signal! output new-value)))))
    (add-action! a1 and-action-procedure)
    (add-action! a2 and-action-procedure)
    'ok)
  ;; ex 3.28
  (define (or-gate a1 a2 output)
    (define (or-action-procedure)
      (let ((new-value
             (logical-or (get-signal a1) (get-signal a2))))
        (after-delay or-gate-delay
                     (lambda ()
                       (set-signal! output new-value)))))
    (add-action! a1 or-action-procedure)
    (add-action! a2 or-action-procedure)
    'ok)
  ;; ex 3.29
  (define (or-gate-e a1 a2 output)
    (let ((a (make-wire))
          (b (make-wire))
          (c (make-wire)))
      (inverter a1 a)
      (inverter a2 b)
      (and-gate a b c)
      (inverter c output))
    'ok)
  (define (half-adder a b s c)
    (let ((d (make-wire)) (e (make-wire)))
      (or-gate a b d)
      (and-gate a b c)
      (inverter c e)
      (and-gate d e s)
      'ok))
  (define (full-adder a b c-in sum c-out)
    (let ((s (make-wire))
          (c1 (make-wire))
          (c2 (make-wire)))
      (half-adder b c-in s c1)
      (half-adder a s sum c2)
      (or-gate c1 c2 c-out)
      'ok))
  ;; ex 3.30
  (define (ripple-carry-adder Ak Bk Sk C)
    (define (ripple-carry-iter Ak Bk Sk c-out)
      (cond ((not (eq? '() Ak))
             (full-adder (car Ak) (car Bk) c-out (car Sk) c-out)
             (ripple-carry-iter (cdr Ak) (cdr Bk) (cdr Sk) c-out))))
    (set-signal! C 0)
    (ripple-carry-iter Ak Bk Sk C)
    'ok)
  
  (define (make-wire)
    (let ((signal-value 0) (action-procedures '()))
      (define (set-my-signal! new-value)
        (if (not (= signal-value new-value))
            (begin (set! signal-value new-value)
                   (call-each action-procedures))
            'done))
      (define (accept-action-procedure! proc)
        (set! action-procedures (cons proc action-procedures))
        (proc))
      (define (dispatch m)
        (cond ((eq? m 'get-signal) signal-value)
              ((eq? m 'set-signal!) set-my-signal!)
              ((eq? m 'add-action!) accept-action-procedure!)))
      dispatch))
  (define (call-each procs)
    (if (null? procs)
        'done
        (begin ((car procs))
               (call-each (cdr procs)))))
  (define (get-signal wire)
    (wire 'get-signal))
  (define (set-signal! wire new-value)
    ((wire 'set-signal!) new-value))
  (define (add-action! wire action)
    ((wire 'add-action!) action))
  
  ;; after-delay
  (define (after-delay delay action)
    (add-to-agenda! (+ delay (current-time the-agenda))
                    action
                    the-agenda))
  
  (define (propagate)
    (if (empty-agenda? the-agenda)
        'done
        (let ((first-item (first-agenda-item the-agenda)))
          (first-item)
          (remove-first-agenda-item! the-agenda)
          (propagate))))
  
  ;;
  
  (define (make-time-segment time queue)
    (cons time queue))
  (define (segment-time s)
    (car s))
  (define (segment-queue s)
    (cdr s))
  
  
  (define (set-current-time! agenda time)
    (set-car! agenda time))
  (define (segments agenda) (cdr agenda))
  (define (set-segments! agenda segments)
    (set-cdr! agenda segments))
  (define (first-segment agenda) (car (segments agenda)))
  (define (rest-segments agenda) (cdr (segments agenda)))
  (define (empty-agenda? agenda)
    (null? (segments agenda)))
  (define (add-to-agenda! time action agenda)
    (define (belongs-before? segments)
      (or (null? segments)
          (< time (segment-time (car segments)))))
    (define (make-new-time-segment time action)
      (let ((q (make-queue)))
        (insert-queue! q action)
        (make-time-segment time q)))
    (define (add-to-segments! segments)
      (if (= (segment-time (car segments)) time)
          (insert-queue! (segment-queue (car segments))
                         action)
          (let ((rest (cdr segments)))
            (if (belongs-before? rest)
                (set-cdr! 
                 segments
                 (cons (make-new-time-segment time action)
                       (cdr segments)))
                (add-to-segments! rest)))))
    (let ((segments (segments agenda)))
      (if (belongs-before? segments)
          (set-segments!
           agenda
           (cons (make-new-time-segment time action)
                 segments))
          (add-to-segments! segments))))
  
  (define (remove-first-agenda-item! agenda)
    (let ((q (segment-queue (first-segment agenda))))
      (delete-queue! q)
      (if (empty-queue? q)
          (set-segments! agenda (rest-segments agenda)))))
  
  (define (first-agenda-item agenda)
    (if (empty-agenda? agenda)
        (error "agenda is empty -- FIRST-AGENDA-ITEM")
        (let ((first-seg (first-segment agenda)))
          (set-current-time! agenda (segment-time first-seg))
          (front-queue (segment-queue first-seg)))))
  
  (define (probe name wire)
    (add-action! wire
                 (lambda ()
                   (newline)
                   (display name)
                   (display " ")
                   (display (current-time the-agenda))
                   (display " New-value = ")
                   (display (get-signal wire)))))
  
  (define (make-agenda) (list 0))
  (define the-agenda (make-agenda))
  (define inverter-delay 2)
  (define and-gate-delay 3)
  (define or-gate-delay 5)
  (define (current-time agenda) (car agenda))
  (define input-1 (make-wire))
  (define input-2 (make-wire))
  (define sum (make-wire))
  (define carry (make-wire))
  (probe 'sum sum)
  (probe 'carry carry)
  (half-adder input-1 input-2 sum carry)
  (set-signal! input-1 1)
  (propagate)
  (set-signal! input-2 1)
  (propagate)
  

  2. 约束系统

  #lang racket
  (require r5rs)
  
  (define (adder a1 a2 sum)
    (define (process-new-value)
      (cond ((and (has-value? a1) (has-value? a2))
             (set-value! sum
                         (+ (get-value a1) (get-value a2))
                         me))
            ((and (has-value? a1) (has-value? sum))
             (set-value! a2
                         (- (get-value  sum) (get-value a1))
                         me))
            ((and (has-value? a2) (has-value? sum))
             (set-value! a1
                         (- (get-value sum) (get-value a2))
                         me))))
    (define (process-forget-value)
      (forget-value! sum me)
      (forget-value! a1 me)
      (forget-value! a2 me)
      (process-new-value))
    (define (me request)
      (cond ((eq? request 'I-have-a-value)
             (process-new-value))
            ((eq? request 'I-lost-my-value)
             (process-forget-value))
            (else
             (error "Unknow request -- ADDER" request))))
    (connect a1 me)
    (connect a2 me)
    (connect sum me)
    me)
  (define (inform-about-value constraint)
    (constraint 'I-have-a-value))
  (define (inform-about-no-value constraint)
    (constraint 'I-lost-my-value))
  (define (multiplier m1 m2 product)
    (define (process-new-value)
      (cond ((or (and (has-value? m1) (= (get-value m1) 0))
                 (and (has-value? m2) (= (get-value m2) 0)))
             (set-value! product 0 me))
            ((and (has-value? m1) (has-value? m2))
             (set-value! product
                         (* (get-value m1) (get-value m2))
                         me))
            ((and (has-value? m1) (has-value? product))
             (set-value! m2
                         (/ (get-value product) (get-value m1))
                         me))
            ((and (has-value? m2) (has-value? product))
             (set-value! m1
                         (/ (get-value product) (get-value m2))
                         me))))
    (define (process-forget-value)
      (forget-value! product me)
      (forget-value! m1 me)
      (forget-value! m2 me)
      (process-new-value))
    (define (me request)
      (cond ((eq? request 'I-have-a-value)
             (process-new-value))
            ((eq? request 'I-lost-my-value)
             (process-forget-value))
            (else
             (error "Unknown request -- MULTIPLIER" request))))
    (connect m1 me)
    (connect m2 me)
    (connect product me)
    me)
  (define (constant value connector)
    (define (me request)
      (error "Unknown request -- CONSTANT" request))
    (connect connector me)
    (set-value! connector value me)
    me)
  (define (probe name connector)
    (define (print-probe value)
      (newline)
      (display "Probe: ")
      (display " = ")
      (display value))
    (define (process-new-value)
      (print-probe (get-value connector)))
    (define (process-forget-value)
      (print-probe "?"))
    (define (me request)
      (cond ((eq? request 'I-have-a-value)
             (process-new-value))
            ((eq? request 'I-lost-my-value)
             (process-forget-value))
            (else
             (error "Unknown request -- PROBE" request))))
    (connect connector me)
    me)
  
  (define (make-connector)
    (let ((value false) (informant false) (constraints '()))
      (define (set-my-value newval setter)
        (cond ((not (has-value? me))
               (set! value newval)
               (set! informant setter)
               (for-each-except setter
                                inform-about-value
                                constraints))
              ((not (= value newval))
               (error "Constradiction" (list value newval)))
              (else 'ignored)))
      (define (forget-my-value retractor)
        (if (eq? retractor informant)
            (begin (set! informant false)
                   (for-each-except retractor
                                    inform-about-no-value
                                    constraints))
            'ignored))
      (define (connect new-constraint)
        (if (not (memq new-constraint constraints))
            (set! constraints
                  (cons new-constraint constraints)))
        (if (has-value? me)
            (inform-about-value new-constraint))
        'done)
      (define (me request)
        (cond ((eq? request 'has-value?)
               (if informant true false))
              ((eq? request 'value) value)
              ((eq? request 'set-value!) set-my-value)
              ((eq? request 'forget) forget-my-value)
              ((eq? request 'connect) connect)
              (else (error "Unknown operation -- CONNECTOR"
                           request))))
      me))
  
  (define (for-each-except exception procedure list)
    (define (loop items)
      (cond ((null? items) 'done)
            ((eq? (car items) exception) (loop (cdr items)))
            (else
             (procedure (car items))
             (loop (cdr items)))))
    (loop list))
  
  (define (has-value? connector)
    (connector 'has-value?))
  (define (get-value connector)
    (connector 'value))
  (define (set-value! connector new-value informant)
    ((connector 'set-value!) new-value informant))
  (define (forget-value! connector retractor)
    ((connector 'forget) retractor))
  (define (connect connector new-constraint)
    ((connector 'connect) new-constraint))
  
  (define C (make-connector))
  (define F (make-connector))
  (define (celsius-fahrenheit-converter c f)
    (let ((u (make-connector))
          (v (make-connector))
          (w (make-connector))
          (x (make-connector))
          (y (make-connector)))
      (multiplier c w u)
      (multiplier v x u)
      (adder v y f)
      (constant 9 w)
      (constant 5 x)
      (constant 32 y)
      'ok))
  (celsius-fahrenheit-converter C F)
  
  (probe "Celsius temp" C)
  (probe "Fahrenheit temp" F)
  (set-value! C 25 'user)
  (forget-value! C 'user)
  (set-value! F 212 'user)
  ;; ex 3.33
  
  (define (average a b c)
    (define (process-new-value)
      (cond ((and (has-value? a) (has-value? b))
             (set-value! c 
                         (/ (+ (get-value a) (get-value b)) 2)
                         me))
            ((and (has-value? a) (has-value? c))
             (set-value! b (- (* 2 (get-value c)) (get-value a))
                         me))
            ((and (has-value? b) (has-value? c))
             (set-value! a (- (* 2 (get-value c)) (get-value b))
                         me))))
    (define (process-forget-value)
      (forget-value! a me)
      (forget-value! b me)
      (forget-value! b me)
      (process-new-value))
    (define (me request)
      (cond ((eq? request 'I-have-a-value)
             (process-new-value))
            ((eq? request 'I-lost-my-value)
             (process-forget-value))
            (else
             (error "Unknow request -- AVERAGE" request))))
    (connect a me)
    (connect b me)
    (connect c me)
    me)
  ;; ex 3.34
  ;; ex 3.35
  (define (squarer a b)
    (define (process-new-value)
      (if (has-value? b)
          (if (< (get-value b) 0)
              (error "square less than 0 --SQUARER" (get-value b))
              (set-value! a
                          (sqrt (get-value b))
                          me))
          (if (has-value? a)
              (if (< (get-value a) 0)
                  (error "square less than 0 --SQUARE" (get-value a))
                  (set-value! b
                              (* (get-value a) (get-value a))
                              me)))))
    (define (process-forget-value)
      (forget-value! a)
      (forget-value! b)
      (process-new-value))
    (define (me request)
      (cond ((eq? request 'I-have-a-value)
             (process-new-value))
            ((eq? request 'I-lost-my-value)
             (process-forget-value))
            (else
             (error "Unknow request -- SQUARER" request))))
    (connect a me)
    (connect b me)
    me)
  ;; ex 3.36
  ;; ex 3.37
  (define (c+ x y)
    (let ((z (make-connector)))
      (adder x y z)
      z))
  (define (c- x y)
    (let ((z (make-connector)))
      (adder z y x)
      z))
  (define (c* x y)
    (let ((z (make-connector)))
      (multiplier x y z)
    z))
  (define (c/ x y)
    (let ((z (make-connector)))
      (multiplier z y x)
      z))
  

  (收起)

  2012-01-11 10:31:38   1回应

  收藏

  推荐