计算机程序的构造和解释 (豆瓣)

作者: Harold Abelson / Gerald Jay Sussman / Julie Sussman
译者: 裘宗燕
出版社: 机械工业出版社
出版年: 2004-2
页数: 473
定价: 45.00元
装帧: 简裝本
丛书: 计算机科学丛书
ISBN: 9787111135104

9.5

(696人评价)

79.3%

17.5%

2.6%

0.4%

0.1%

想读在读读过

评价:

作者简介 · · · · · ·

　　Harold Abelson是MIT1992年度MacVicarFacultyFellow。Gerald JaySussman是Matsushita电子工程教授。他们都在MIT电子工程和计算机科学系工作．都得到过最重要的计算机科学教育奖：如Abelson得到了IEEE计算机学会的Booth奖。Sussman得到了ACM的Karlstrom奖。
　　Julie Sussman是作家和编辑，同时使用自然语言和计算机语言写作。

豆瓣成员常用的标签(共299个) · · · · · ·

计算机科学(657) SICP(411) 计算机(384) 编程(358) 程序设计(240) LISP(214) 经典(197) Scheme(192)

丛书信息

　　计算机科学丛书 (共51册), 这套丛书还有《信息安全工程》,《软件工程：实践者的研究方法（原书第 5 版）》,《机器学习导论》,《深入理解计算机系统（原书第2版）》,《人工智能》等。

喜欢读"计算机程序的构造和解释"的人也喜欢 · · · · · ·

: 代码大全（第2版）

: 程序设计实践

: 深度探索C++对象模型

: 具体数学

: 高效程序的奥秘

: 程序员修炼之道

: 编程珠玑

: C++语言的设计和演化

: 编程珠玑(第二版)

: 编程珠玑

读书笔记 · · · · · · (共42篇)
我来写笔记

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

第1页

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

读书笔记第一章题解~ http://www.freopen.com/?p=10382 第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385 第三章已经看完了,不过最近比较忙,练习需要等等再写~ P.S. 建了一个"计算机科学"的QQ群:20076724~欢迎加入!~ (更多)

读书笔记
第一章题解~ http://www.freopen.com/?p=10382
第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385
第三章已经看完了,不过最近比较忙,练习需要等等再写~
P.S.
建了一个"计算机科学"的QQ群:20076724~欢迎加入!~ (收起)

2011-04-05 04:40:34 4人收藏 4回应

收藏
推荐
第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页

Vh

抽象是关键先看 pratical lisp 先再看好看 (更多)

抽象是关键
先看 pratical lisp 先再看好看 (收起)

2011-03-31 16:50:08 回应

收藏
推荐
第1页

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

读书笔记第一章题解~ http://www.freopen.com/?p=10382 第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385 第三章已经看完了,不过最近比较忙,练习需要等等再写~ P.S. 建了一个"计算机科学"的QQ群:20076724~欢迎加入!~ (更多)

读书笔记
第一章题解~ http://www.freopen.com/?p=10382
第二章题解~最后两个通用系统的练习没写,代码量太大~ http://www.freopen.com/?p=10385
第三章已经看完了,不过最近比较忙,练习需要等等再写~
P.S.
建了一个"计算机科学"的QQ群:20076724~欢迎加入!~ (收起)

2011-04-05 04:40:34 4人收藏 4回应

收藏
推荐
第1页

竹林 (给生活加点糖~~)

一篇很好的书评，做个标记。 http://www.cnblogs.com/JeffreyZhao/archive/2009/07/15/recommended-reading-2-sicp.html (更多)

一篇很好的书评，做个标记。 http://www.cnblogs.com/JeffreyZhao/archive/2009/07/15/recommended-reading-2-sicp.html (收起)

2011-05-22 22:12:55 回应

收藏
推荐

4.1 元循环求值器

老徐 (美的很。)

随着所面对的问题变得更加复杂，我们会发现Lisp,以及任何一种确定的程序设计语言，都不足以满足我们的需要，我们必须经常转向新的语言，以便能够更有效地表述自己的想法。建立新语言是工程设计中控制复杂性的一种威力强大的工作策略，我们常常能通过采用一种新语言而提升处理复杂问题的能力，因为新语言可能使我们以一种完全不同的方式，利用不同的原语，不同的组合方式和抽象方式去描述所面对的问题，而这些都可以是为了手... (更多)

元语言抽象就是简历新的语言。（元编程）

以下是书中实现的一个求值器，源代码；可以将代码中的primitive操作符，数字，引用(quote),lambda,define,set!等理解为lexer（词法）；而一下程序将语法分析和计算混杂在一起。后边有一节将把语法分析和计算程序隔离开；

#lang scheme
(require r5rs)
;; eval and apply

(define apply-in-underlying-scheme apply)
(define (eval-i exp env)
  (cond ((self-evaluating? exp) exp)
        ((variable? exp) (lookup-variable-value exp env))
        ((quoted? exp) (text-of-quotation exp))
        ((assignment? exp) (eval-assignment exp env))
        ((definition? exp) (eval-definition exp env))
        ((if? exp) (eval-if exp env))
        ((lambda? exp)
         (make-procedure (lambda-parameters exp)
                         (lambda-body exp)
                         env))
        ((begin? exp)
         (eval-sequence (begin-actions exp) env))
        ((cond? exp) (eval-i (cond->if exp) env))
        ((application? exp)
         (apply-i (eval-i (operator exp) env)
                  (list-of-values (operands exp) env)))
        (else 
         (error "Unknow expression type --EVAL" exp))))

(define (apply-i procedure arguments)
  (cond ((primitive-procedure? procedure)
         (apply-primitive-procedure procedure arguments))
        ((compound-procedure? procedure)
         (eval-sequence
          (procedure-body procedure)
          (extend-environment
           (procedure-parameters procedure)
           arguments
           (procedure-environment procedure))))
        (else
         (error "Unknow procedure type --APPLY" procedure))))

(define (list-of-values exps env)
  (if (no-operands? exps)
      '()
      (cons (eval-i (first-operand exps) env)
            (list-of-values (rest-operands exps) env))))
(define (eval-if exp env)
  (if (true? (eval-i (if-predicate exp) env))
      (eval-i (if-consequent exp) env)
      (eval-i (if-alternative exp) env)))
(define (eval-sequence exps env)
  (cond ((last-exp? exps) (eval-i (first-exp exps) env))
        (else (eval-i (first-exp exps) env)
              (eval-sequence (rest-exps exps) env))))
(define (eval-assignment exp env)
  (set-variable-value! (assignment-variable exp)
                       (eval-i (assignment-value exp) env)
                       env)
  'ok)
(define (eval-definition exp env)
  (define-variable! (definition-variable exp)
    (eval-i (definition-value exp) env)
    env)
  'ok)

(define (self-evaluating? exp)
  (cond ((number? exp) true)
        ((string? exp) true)
        (else false)))
(define (variable? exp) (symbol? exp))
(define (quoted? exp)
  (tagged-list? exp 'quote))
(define (text-of-quotation exp)
  (cadr exp))
(define (tagged-list? exp tag)
  (if (pair? exp)
      (eq? (car exp) tag)
      false))
(define (assignment? exp)
  (tagged-list? exp 'set!))
(define (assignment-variable exp) (cadr exp))
(define (assignment-value exp) (caddr exp))
(define (definition? exp)
  (tagged-list? exp 'define))

(define (definition-variable exp)
  (if (symbol? (cadr exp))
      (cadr exp)
      (caadr exp)))
(define (definition-value exp)
  (if (symbol? (cadr exp))
      (caddr exp)
      (make-lambda (cdadr exp)
                   (cddr exp))))
(define (lambda? exp) (tagged-list? exp 'lambda))
(define (lambda-parameters exp) (cadr exp))
(define (lambda-body exp) (cddr exp))
(define (make-lambda parameters body)
  (cons 'lambda (cons parameters body)))
(define (if? exp) (tagged-list? exp 'if))
(define (if-predicate exp) (cadr exp))
(define (if-consequent exp) (caddr exp))
(define (if-alternative exp)
  (if (not (null? (cadddr exp)))
      (cadddr exp)
      'false))
(define (make-if predicate consequent alternative)
  (list 'if predicate consequent alternative))
(define (begin? exp) (tagged-list? exp 'begin))
(define (begin-actions exp) (cdr exp))
(define (last-exp? seq) (null? (cdr seq)))
(define (first-exp seq) (car seq))
(define (rest-exps seq) (cdr seq))
(define (sequence->exp seq)
  (cond ((null? seq) seq)
        ((last-exp? seq) (first-exp seq))
        (else (make-begin seq))))
(define (make-begin seq) (cons 'begin seq))
(define (application? exp) (pair? exp))
(define (operator exp) (car exp))
(define (operands exp) (cdr exp))
(define (no-operands? ops) (null? ops))
(define (first-operand ops) (car ops))
(define (rest-operands ops) (cdr ops))

(define (cond? exp) (tagged-list? exp 'cond))
(define (cond-clauses exp) (cdr exp))
(define (cond-else-clause? clause)
  (eq? (cond-predicate clause) 'else))
(define (cond-predicate clause) (car clause))
(define (cond-actions clause) (cdr clause))
(define (cond->if exp)
  (expand-clauses (cond-clauses exp)))
(define (expand-clauses clauses)
  (if (null? clauses)
      'false
      (let ((first (car clauses))
            (rest (cdr clauses)))
        (if (cond-else-clause? first)
            (if (null? rest)
                (sequence->exp (cond-actions first))
                (error "ELSE clause isn't last --COND-IF"
                       clauses))
            (make-if (cond-predicate first)
                     (sequence->exp (cond-actions first))
                     (expand-clauses rest))))))

(define (true? x)
  (not (eq? x false)))

(define (false? x)
  (eq? x false))
;(define (apply-primitive-procedure proc args)
;(define (primitive-procedure proc)1 
(define (make-procedure parameters body env)
  (list 'procedure parameters body env))
(define (compound-procedure? p)
  (tagged-list? p 'procedure))
(define (procedure-parameters p) (cadr p))
(define (procedure-body p) (caddr p))
(define (procedure-environment p) (cadddr p))
;(define (lookup-variable-value var env)
;(extend-environment variables values base-env)
;;(define-variable! var value env)
;; (set-variable-value! var value env)
(define (enclosing-environment env) (cdr env))
(define (first-frame env) (car env))
(define the-empty-environment '())
(define (make-frame variables values)
  (cons variables values))
(define (frame-variables frame) (car frame))
(define (frame-values frame) (cdr frame))
(define (add-binding-to-frame! var val frame)
  (set-car! frame (cons var (car frame)))
  (set-cdr! frame (cons val (cdr frame))))
(define (extend-environment vars vals base-env)
  (if (= (length vars) (length vals))
      (cons (make-frame vars vals) base-env)
      (if (< (length vars) (length vals))
          (error "Too many arguments supplied" vars vals)
          (error "Too few arguments supplied" vars vals))))
(define (lookup-variable-value var env)
  (define (env-loop env)
    (define (scan vars vals)
      (cond ((null? vars)
             (env-loop (enclosing-environment env)))
            ((eq? var (car vars))
             (car vals))
            (else (scan (cdr vars) (cdr vals)))))
    (if (eq? env the-empty-environment)
        (error "Unbound variable" var)
        (let ((frame (first-frame env)))
          (scan (frame-variables frame)
                (frame-values frame)))))
  (env-loop env))
(define (set-variable-value! var val env)
  (define (env-loop env)
    (define (scan vars vals)
      (cond ((null? vars)
             (env-loop (enclosing-environment env)))
            ((eq? var (car vars))
             (set-car! vals val))
            (else (scan (cdr vars) (cdr vals)))))
    (if (eq? env the-empty-environment)
        (error "Unbound variable -- SET!" var)
        (let ((frame (first-frame env)))
          (scan (frame-variables frame)
                (frame-values frame)))))
  (env-loop env))
(define (define-variable! var val env)
  (let ((frame (first-frame env)))
    (define (scan vars vals)
      (cond ((null? vars)
             (add-binding-to-frame! var val frame))
            ((eq? var (car vars))
             (set-car! vals val))
            (else (scan (cdr vars) (cdr vals)))))
    (scan (frame-variables frame)
          (frame-values frame))))
(define (primitive-procedure? proc)
  (tagged-list? proc 'primitive))
(define (primitive-implementation proc) (cadr proc))
(define primitive-procedures
  (list (list 'car car)
        (list 'cdr cdr)
        (list 'cons cons)
        (list 'null? null?)
        (list '- -)

        ;; more primitive proc
        ))
(define (primitive-procedure-names)
  (map car 
       primitive-procedures))
(define (primitive-procedure-objects)
  (map (lambda (proc) (list 'primitive (cadr proc)))
       primitive-procedures))
(define (setup-environment)
  (let ((initial-env
         (extend-environment (primitive-procedure-names)
                             (primitive-procedure-objects)
                             the-empty-environment)))
    (define-variable! 'true true initial-env)
    (define-variable! 'false false initial-env)
    initial-env))
(define the-global-environment (setup-environment))

(define (apply-primitive-procedure proc args)
  (apply-in-underlying-scheme
   (primitive-implementation proc) args))

(define input-prompt ";;;M-Eval input:")
(define output-prompt ";;; M-Eval value:")
(define (driver-loop)
  (prompt-for-input input-prompt)
  (let ((input (read)))
    (let ((output (eval-i input the-global-environment)))
      (announce-output output-prompt)
      (user-print output)))
  (driver-loop))
(define (prompt-for-input string)
  (newline) (newline) (display string) (newline))
(define (announce-output string)
  (newline) (display string) (newline))
(define (user-print object)
  (if (compound-procedure? object)
      (display (list 'compund-procedure
                     (procedure-parameters object)
                     (procedure-body object)
                     '<procedure-env>))
      (display object)))
(driver-loop)

(收起)

2012-02-03 18:33:19 回应

4.4

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

1.query的means of combination跟finite automata一样诶 2.逻辑效率问题: 数学上的逻辑不考虑执行效率问题,但是逻辑编程语言显然会碰到效率问题,(and x y)和(and y x)在计算时间上可能相差巨大. 而这个问题的极端情况就是某种顺序陷入infinite loop,计算需要的时间无限长. 所以,从效率的角度看,逻辑运算and/or都不满足交换律. 3.真值问题: 这里的and/or可以认为是enumerator,生成的都从data base中deducible,隐含了close... (更多)

1.query的means of combination跟finite automata一样诶
2.逻辑效率问题:
数学上的逻辑不考虑执行效率问题,但是逻辑编程语言显然会碰到效率问题,(and x y)和(and y x)在计算时间上可能相差巨大.
而这个问题的极端情况就是某种顺序陷入infinite loop,计算需要的时间无限长.
所以,从效率的角度看,逻辑运算and/or都不满足交换律.
3.真值问题:
这里的and/or可以认为是enumerator,生成的都从data base中deducible,隐含了closed world assumption;
而这里的(not x)是个filter,把从data base中推断出满足x的丢掉,剩下的留下.也就是说生成结果中有肯定!x的(!表示逻辑上的非,以区别query里的not),也有不知道是不是!x的.这里隐含的是open world assumption;
也就是说这个系统的假设不一致......
所以,同时含有not 和 and/or 的命题就混乱了,按照逻辑运算的法则进行一些变换可能导致结果不一致. (收起)

2012-01-30 16:14:31 回应

收藏
推荐
第1页

quickwind

看了豆瓣上的统计，想读的有3千多人，读过的就有4百多人，看来这边书名气大，但是读的人少啊，不好读啊 (更多)

看了豆瓣上的统计，想读的有3千多人，读过的就有4百多人，看来这边书名气大，但是读的人少啊，不好读啊 (收起)

2012-01-30 13:27:35 回应

收藏
推荐

> 更多读书笔记（共42篇）

书评 · · · · · · (共32条) 我来评论这本书

"计算机程序的构造和解释"的论坛 · · · · · ·


SICP资源汇总	来自kay	11 回应	2011-07-15
计算机程序的构造和解释勘误表	来自洛奇	1 回应	2009-06-23
OMG! it is hard!	来自狮子真好吃啊	2 回应	2009-02-14
OMG! it is hard!	来自狮子真好吃啊		2005-12-23
可以给六星了	来自jtuki	8 回应	2009-02-19

> 浏览更多话题

豆瓣购书单 ( iOS / Android )

在哪儿买这本书? · · · · · ·

9本二手书欲转让 (1.00 至 480.00元)
> 点这儿转让有3519人想读,手里有一本闲着?

在哪儿借这本书? · · · · · ·

这本书的其他版本 · · · · · · ( 全部5 )

The MIT Press版 1998-9-15 / 30人读过 / 有售
The MIT Press版 25 July, 1996 / 182人读过
McGraw-Hill Science/Engineering/Math版 1996-8-1 / 2人读过
The MIT Press版 1996-9-1 / 3人读过

以下豆列推荐 · · · · · · (全部)

谁读这本书?

92驱魔师

24分钟前想读

tags:软件开发计算机科学

苦大仇深潴糰掌

今天下午想读

星游

今天凌晨想读

tags:SICP
据说是神级的SICP

昨天在读

喜欢这本书的人常去的小组 · · · · · ·

: LISP (2011)

: Haskell (888)

: scheme (446)

: TAOCP (614)

: Emacs (2340)

: Erlang (1031)

: Vim (6198)

: Compiler (753)

喜欢这本书的人关注的活动 · · · · · ·

统计学习理论读书会

时间：2012-02-19 14:00
地点：北京海淀区双榆树叁号会所
97人关注
量子决策理论读书会

时间：2011-12-25 14:00
地点：北京海淀区双榆树叁号会所
134人关注
40元的价格邀您观看IMAX70毫米胶片版巨幕影片《碟中谍4：幽灵协议》

时间：2012-01-28 00:00
地点：北京朝阳区朝阳其它南影路9号
500人关注

> 收藏这本书的所有小组

订阅关于计算机程序的构造和解释的评论:
feed: rss 2.0

计算机程序的构造和解释

作者简介 · · · · · ·

豆瓣成员常用的标签(共299个) · · · · · ·

丛书信息

喜欢读"计算机程序的构造和解释"的人也喜欢 · · · · · ·

读书笔记 · · · · · · (共42篇)
我来写笔记

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

第1页

第271页

3.3 数字电路模拟器

第1页

第1页

第1页

4.1 元循环求值器

4.4

第1页

书评 · · · · · · (共32条) 我来评论这本书

热门评论  最新评论

时间的女儿

本书的内容，以及我们能从中学到什么

我为什么推荐 SICP？

涵盖面很广，起点很高

MIT免费教程video下载

一本独一无二的入门书

神作，IT 男必读

FIX POINT - 岿然不动，谙知万物。

抽象能力

编程思想很全面的一本书

计算机程序理论经典

"计算机程序的构造和解释"的论坛 · · · · · ·

在哪儿买这本书? · · · · · ·

在哪儿借这本书? · · · · · ·

这本书的其他版本 · · · · · · ( 全部5 )

以下豆列推荐 · · · · · · (全部)

谁读这本书?

喜欢这本书的人常去的小组 · · · · · ·

喜欢这本书的人关注的活动 · · · · · ·

计算机程序的构造和解释

作者简介 · · · · · ·

豆瓣成员常用的标签(共299个) · · · · · ·

丛书信息

喜欢读"计算机程序的构造和解释"的人也喜欢 · · · · · ·

读书笔记 · · · · · · (共42篇) 我来写笔记

书评 · · · · · · (共32条) 我来评论这本书

"计算机程序的构造和解释"的论坛 · · · · · ·

在哪儿买这本书? · · · · · ·

在哪儿借这本书? · · · · · ·

这本书的其他版本 · · · · · · ( 全部5 )

以下豆列推荐 · · · · · · (全部)

谁读这本书?

喜欢这本书的人常去的小组 · · · · · ·

喜欢这本书的人关注的活动 · · · · · ·

读书笔记 · · · · · · (共42篇)
我来写笔记