BlogJava-庄周梦蝶，孰蝶是我，我是孰蝶？一梦至今，蝶我已难分-随笔分类-计算机科学与基础

sicp3.5.2、3.5.3节部分习题尝试解答

dennis — Tue, 13 May 2008 15:52:00 GMT

本节主要讲述无穷流。
3.53，显然

(define s (cons-stream 1 (add-stream s s)))

定义是2的n次方组成的无穷数列，2,4,8,16,32...

3.54，定义阶乘组成的无穷序列：

(define (mul-streams s1 s2)
(stream-map * s1 s2))
(define factorials (cons-stream 1 (mul-streams factorials (stream-cdr integers))))

3.55解答，比较有趣，也是不难的题目，列出来找出规律就成了，就是将(stream-car s)加到生成的序列中的每个元素上，通过stream-map，最后的结果就是每个元素都是前n个元素累积的结果，我的解答：

(define (partial-sums s)
(cons-stream (stream-car s) (stream-map (lambda(x) (+ x (stream-car s))) (partial-sums (stream-cdr s)))))

3.56，有了merge就好办了，根据条件合并起3种情况来就好：

(define S (cons-stream 1 (merge (scale-stream s 2) (merge (scale-stream s 3) (scale-stream s 5)))))

3.57,略过

3.58，观察到，num每次都与radix相乘并且radix保持不变，那么radix可以认为是一个基数，den也保持不变作为除数，那么这个序列就是以radix为基数对den求整数商的序列，不明白num为什么每次要变换成余数？这个序列有啥特别的用途呢？未解。

(expand 1 7 10)

=> 1 4 2 8 5 7 1 4 2 8



(expand 3 8 10)

=> 3 7 5 0 0 0 0 0 0 0

3.59解答：
a)只要将序列通过前面定义的mul-streams与整数的倒数序列相乘：

(define (integrate-series s)
(mul-streams (stream-map (lambda(x) (/ 1 x)) integers) s))

b)照着定义来了，cons的级数注意使用scale-stream乘以-1：

(define sine-series
  (cons-stream 0 (integrate-series cosine-series)))

(define cosine-series
  (cons-stream 1
    (scale-stream
      (integrate-series sine-series)
      -1)))

3.64解答：

(define (stream-limit s tolerance)
  (define (stream-limit-iter stream current)
    (cond ((or (stream-null? stream) (null? (stream-car stream))) #f)
          (else
           (let ((next (stream-car stream)))
             (if (< (abs (- next current)) tolerance)
                   next
                  (stream-limit-iter (stream-cdr stream) next))))))
  (stream-limit-iter (stream-cdr s) (stream-car s)))

习题3.65：

(define (ln-summands n)
(cons-stream (/ 1.0 n)
(stream-map - (ln-summands (+ n 1)))))
(define ln-stream (partial-sums (ln-summands 1)))
(define ln-stream2 (euler-transform ln-stream))
(define ln-stream3 (accelerated-sequence euler-transform ln-stream))

经过欧拉变换加速过的级数收敛的很快，测测就知道

dennis 2008-05-13 23:52 发表评论

scheme解决约瑟夫环问题（续）

dennis — Wed, 16 Apr 2008 02:27:00 GMT

sicp的习题3.22，也就是以消息传递的风格重新实现队列，我的解答如下：

(define (make-queue)
  (let ((front-ptr '())
        (rear-ptr '()))
  (define (set-front-ptr! ptr) (set! front-ptr ptr))
  (define (set-rear-ptr! ptr) (set! rear-ptr ptr))
  (define (empty-queue?) (null? front-ptr))
  (define (front-queue)
    (if (empty-queue?)
        (error "FRONT called with an empty queue")
        (car front-ptr)))
  (define (insert-queue! item)
    (let ((new-pair (cons item '())))
      (cond ((empty-queue?)
              (set-front-ptr! new-pair)
              (set-rear-ptr! new-pair))
            (else
               (set-cdr! rear-ptr new-pair)
               (set-rear-ptr! new-pair)))))
  (define (delete-queue!)
      (cond ((empty-queue?)
             (error "DELETE! called with an empty queue" queue))
            (else
               (set-front-ptr! (cdr front-ptr)))))
  (define (dispatch m)
    (cond ((eq? m 'front-queue) (front-queue))
          ((eq? m 'empty-queue?) (empty-queue?))
          ((eq? m 'insert-queue!) insert-queue!)
          ((eq? m 'delete-queue!) delete-queue!)
          (else
             (error "Unknow method" m))))
    dispatch))
(define (front-queue z) (z 'front-queue))
(define (empty-queue? z) (z 'empty-queue?))
(define (insert-queue! z item) ((z 'insert-queue!) item))
(define (delete-queue! z) ((z 'delete-queue!)))

由此，我才知道自己竟然一直没有想到，scheme完全可以模拟单向循环链表，整整第三章都在讲引入赋值带来的影响，而我却视而不见。在引入了改变函数后，数据对象已经具有OO的性质，模拟链表、队列、table都变的易如反掌。首先，模拟节点对象，节点是一个序对，包括当前节点编号和下一个节点：

(define (make-node n next) (cons n next))
(define (set-next-node! node next) (set-cdr! node next))
(define (set-node-number! node n) (set-car! node n))
(define (get-number node) (car node))
(define (get-next-node node) (cdr node))

有了节点，实现了下单向循环链表：

(define (make-cycle-list n)
  (let ((head (make-node 1 '())))
    (define (make-list current i)
      (let ((next-node (make-node (+ i 1) '())))
        (cond ((= i n) current)
              (else
                (set-next-node! current next-node)
                (make-list next-node (+ i 1))))))
    (set-next-node! (make-list head 1) head)
    head))

make-cycle-list生成一个有N个元素的环形链表，比如(make-cycle-list 8)的结果如下
#0=(1 2 3 4 5 6 7 8 . #0#)
Drscheme形象地展示了这是一个循环的链表。那么约瑟夫环的问题就简单了：

(define (josephus-cycle n m)
  (let ((head (make-cycle-list n)))
    (define (josephus-iter prev current i)
      (let ((next-node (get-next-node current)))
       (cond ((eq? next-node current) (get-number current))
             ((= 1 i)
              (set-next-node! prev next-node)
              (josephus-iter prev next-node m))
             (else
               (josephus-iter current next-node (- i 1))))))
    (josephus-iter head head m)))

从head节点开始计数，每到m，就将当前节点删除（通过将前一个节点的next-node设置为current的下一个节点），最后剩下的节点的编号就是答案。

dennis 2008-04-16 10:27 发表评论

关于binary search

dennis — Wed, 02 Apr 2008 02:08:00 GMT

编程珠玑Column 4关于binary search的部分相当精彩，1946年就有人发表binary search，但直到1962第一个正确运行的算法才写出来。尽管算法描述看起来简单明了，但是要写的正确却是有许多地方要仔细考虑。作者着重强调的是对程序正确性的分析方法，仔细分析方法的pre-condition, invariant,和post-condition。g9老大翻译过Joshua Bloch在google blog上的文章《号外，号外，几乎所有的binary search和mergsort都有错》，原文在这里。今天看了下原文，有更新，对于求中值索引的c/c++方法原文仍然是有错的，本来是这样：

int mid = ((unsigned) (low + high)) >> 1。

但是在c99标准中，对于两个signed数值之和，如果溢出结果是未定义的(undefined)，也就是说与编译器实现相关。上面的代码应该修改为：

mid = ((unsigned int)low + (unsigned int)high)) >> 1;

我查了下jdk6的java.util.Arrays的源码，joshua bloch说的这个问题已经解决，现在的binary search如下：

  // Like public version, but without range checks.
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                     int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];

        if (midVal < key)
        low = mid + 1;
        else if (midVal > key)
        high = mid - 1;
        else
        return mid; // key found
    }
    return -(low + 1);  // key not found.
    }

如原文所讨论的，采用了>>>操作符替代除以2

dennis 2008-04-02 10:08 发表评论

scheme解约瑟夫环问题

dennis — Thu, 20 Mar 2008 11:15:00 GMT

看了javaeye上一个解决约瑟夫环的问题的帖子，就想能不能用scheme来解决。如果采用推导出的数学公式来处理当然很简单了：

(define (joseph n m)
  (define (joseph-iter init s)
    (if (> init n)
        (+ s 1)
        (joseph-iter (+ init 1) (remainder (+ s m) init))))
  (joseph-iter 2 0))

我想是否可以用一般的模拟算法来实现？也就是模拟一个循环链表，每次删除第m个元素。弄了个比较丑陋的实现：

(define (enumrate-interval low high)
  (if (> low high)
      '()
      (cons low (enumrate-interval (+ low 1) high))))
(define (delete-last list)
  (if (eq? (cdr list) '())
      '()
      (cons (car list) (delete-last (cdr list)))))

(define (joseph-iter init list it)
  (let ((m (remainder it (length list))))
   (cond ((= m 0) (delete-last list))
         ((= m 1) (append (cdr list) (reverse init)))
         (else
           (joseph-iter (cons (car list) init) (cdr list) (- m 1))))))
(define (joseph n m)
    (define (joseph-list list m)
      (display list)
      (newline)
      (if (eq? (cdr list) '())
          (car list)
          (joseph-list (joseph-iter '() list m) m)))

计算（joseph 8 3)的过程如下：
(1 2 3 4 5 6 7 8)
(4 5 6 7 8 1 2)
(7 8 1 2 4 5)
(2 4 5 7 8)
(7 8 2 4)
(4 7 8)
(4 7)
(7)
7

看了这个计算过程就知道我这个方法多糟糕，每次都重新构造列表。不知道看blog的大大们有没有更好的思路？

dennis 2008-03-20 19:15 发表评论

用递归计算阶乘咋不行呢？

dennis — Tue, 18 Mar 2008 11:34:00 GMT

    读《代码大全2》，已经读了一半，喘口气。总结八个字：百科全书，受益匪浅。小到一个赋值语句、一个循环的编写，大到需求分析、架构设计，无所不包，看后半部分目录，更是扯到了重构、软件工艺、程序员的性格特征这样的话题。恰好手边的工作暂时比较有闲，可以实践下“创建高质量的代码”中的部分建议，晚上读书，第二天就重构，乐在其中。这一部分中对设计、子程序、类、变量、语句的处理建议，可能你平常已经在这么做，可作者这么精辟地概括出来让人叹服，而有些地方是你平常绝对很少注意的，特别是在变量和三种常见控制语句的处理上。

    说说我认为是缺点的地方，就是作者貌似对函数式语言了解很少，举的例子全部用的是广泛应用的静态语言（c/c++,java,vb)。例如作者有这么一句话：如果为我工作的程序员用递归去计算阶乘，那么我宁愿换人。作者对递归的态度相当谨慎，这在静态命令式语言中显然是正确的，但是在函数式语言中，由于有尾递归优化的存在，递归反而是最自然的形式，况且我打心里认为递归更符合人类思维。请注意，在FP中只有尾递归的程序才是线性迭代的，否则写出来的递归可能是线性递归或者树形递归，两种情况下都可能导致堆栈溢出并且性能较差。

scheme写阶乘：

(define (fac n)
  (if (= 1 n)
      1
      (* n (fac (- n 1)))))

显然这个版本不是尾递归，计算过程是一个线性递归过程，计算(fac 4)的过程如下：
(* 4 （fac 3))
(* 4 (3 * (fac 2)))
(* 4 (3 * (* 2 (fac 1))))
(* 4 (3 * (* 2 1)))
(* 4 (3 * 2))
(* 4 6)
24
因为解释器是采用应用序求值，需要将表达式完全展开，然后依次求值，在这个过程中，解释器内部需要保存一条长长的推迟计算的轨迹。
改写成一个尾递归版本：

(define (fac n)
  (define (fac-iter product n)
    (if (= 1 n)
        product
        (fac-iter (* n product) (- n 1))))
  (fac-iter 1 n))

我们来看看它的计算过程：
(fac-iter 1 4)
(fac-iter 4 3)
(fac-iter 12 2)
(fac-iter 24 1)
24
可以看到，在这个过程中，解释器不需要保存计算轨迹，迭代的中间结果通过product变量来保存，这是一个线性迭代的计算过程。
最后再看一个斐波拉契数列的例子：

(define (fib n)
(cond ((= n 0) 0)
            ((= n 1) 1)
            (else
                 (+ (fib (- n 1)) (fib (- n 2))))))

这个计算过程展开是一个树形递归的过程(为什么说是树形？展开下计算过程就知道），改写为线性迭代：

(define (fib n)
  (define (fib-iter a b count)
     (if (= count 0)
         b
         (fib-iter (+ a b) a (- count 1))))
(fib-iter 1 0 n))

上述的内容在sicp第一章里有更详细的介绍和讨论。

dennis 2008-03-18 19:34 发表评论

用Ruby写了个NFA

dennis — Mon, 25 Feb 2008 09:46:00 GMT

今天有点空闲，想想用Ruby写个NFA试试。从正则表达式构造NFA采用经典的Thompson算法:正则表达式 -> 后缀表达式 -> 构造NFA。构造了NFA后，用之匹配字符串。一句话，写了个玩具的正则表达式引擎，支持concatenation、alternation以及*、?、+量词，不支持反向引用和转义符。测试了下与Ruby自带的正则表达式引擎的性能对比，慢了3倍。构造NFA没什么问题，主要是匹配运行写的烂，有空再改改。

nfa.rb

module NFA
  class NFA
    def initialize(state)
      @state=state
    end
    def step(clist,c)
      return clist if clist.size==0;
      nlist=[]
      allNull = true
      matched = false
      clist.each do |t|
        if !t.nil?
          allNull = false if t.c!=-1
          if t.c == c && t.end.type ==1 then
            matched = true
            nlist.push(t.end.out1) if !t.end.out1.end.nil?
            nlist.push(t.end.out2) if !t.end.out2.end.nil?
          elsif (t.c == c && t.end.type == 0) then
            matched = true;
            return ListUitls.new_list(t);
          elsif (t.c == -1 && !t.end.nil?) then
            nlist.push(t.end.out1);
            nlist.push(t.end.out2);
          end
        end
      end
      return step(nlist, c) if (allNull)
      return step(nlist, c) if (!matched)
      nlist
    end
    def test?(s)
      match(@state,s)
    end
    def match(state,s)
      clist =[]
      clist.push(state.out1);
      clist.push(state.out2);
      s.each_byte do |c|
      c =c&0xFF;
        clist = step(clist, c);
        return false if clist.size==0
      end
      return is_match?(clist)
    end
    def is_match?(clist)
      clist.each  do |t|
        return true if !t.nil? and t.c==-1 and t.end and t.end.is_matched?
      end
      false
    end
  end
  class Paren
    attr_accessor:n_alt,:n_atom
  end
  class State
    attr_accessor :out1,:out2,:type
    def initialize(out1,out2)
      @out1=out1
      @out2=out2
      @type=1
    end
    def is_matched?
      return @type==0
    end
  end
  class Transition
    attr_accessor :c,:end
    def initialize(c)
      @c=c
    end
  end
  class Frame
    attr_accessor :start,:outs
    def initialize(start,outs)
      @start=start
      @outs=outs
    end
  end
  class ListUitls
    def self.link(list,state)
      list.each{|t| t.end=state}
    end
    def self.append(list1,list2)
      list1+list2
    end
    def self.new_list(out)
      result=[]
      result.push(out)
      result
    end
  end
  def self.compile(re)
    post = re2post(re)
    raise ArgumentError.new,"bad regexp!" if post.nil?
    state = post2nfa(post);
    raise RuntimeError.new,"construct nfa from postfix fail!" if state.nil?
    return NFA.new(state);
  end
  def self.post2nfa(postfix)
    stack=[]
    s=nil
    t=t1=t2=nil
    e1=e2=e=nil
    return nil if postfix.nil?
    postfix.each_byte do |p|
      case p.chr
      when '.':
        e2 = stack.pop()
        e1 = stack.pop()
        ListUitls.link(e1.outs, e2.start)
        stack.push(Frame.new(e1.start, e2.outs))
      when '|':
        e2 = stack.pop()
        e1 = stack.pop()
        t1 = Transition.new(-1)
        t2 = Transition.new(-1)
        t1.end = e1.start
        t2.end = e2.start
        s = State.new(t1, t2)
        stack.push(Frame.new(s, ListUitls.append(e1.outs, e2.outs)))
      when '?':
        e = stack.pop()
        t1 = Transition.new(-1)
        t2 = Transition.new(-1)
        t1.end = e.start
        s = State.new(t1, t2)
        stack.push(Frame.new(s, ListUitls.append(e.outs, ListUitls.new_list(t2))))
      when '*':
        e = stack.pop()
        t1 = Transition.new(-1)
        t2 = Transition.new(-1)
        t1.end = e.start
        s = State.new(t1, t2)
        ListUitls.link(e.outs, s)
        stack.push(Frame.new(s, ListUitls.new_list(s.out2)))
      when '+':
        e = stack.pop()
        t1 = Transition.new(-1)
        t2 = Transition.new(-1)
        t1.end = e.start
        s = State.new(t1, t2)
        ListUitls.link(e.outs, s)
        stack.push(Frame.new(e.start, ListUitls.new_list(t2)))
      else
        t = Transition.new(p)
        s = State.new(t, Transition.new(-1))
        stack.push(Frame.new(s, ListUitls.new_list(s.out1)))
      end
    end
    e = stack.pop()
    return nil if stack.size()>0
    end_state = State.new(nil, nil)
    end_state.type=0
    e.outs.each do |tran|
      if tran.c!=-1
        t1 = Transition.new(-1)
        t2 = Transition.new(-1)
        s=State.new(t1,t2)
        tran.end=s
        s.out1.end=end_state
        s.out2.end=end_state
      else
        tran.end=end_state
      end
    end
    start = e.start
    return start
  end
  def self.re2post(re)
    n_alt = n_atom = 0
    result=""
    paren=[]
    re.each_byte do |c|
      case c.chr
      when '(' then
        if (n_atom > 1) then
          n_atom-=1
          result<<"."
        end
        p =Paren.new
        p.n_alt = n_alt
        p.n_atom = n_atom
        paren.push(p)
        n_alt = n_atom = 0
      when '|' then
        if (n_atom == 0)
          return nil
        end
        while (n_atom-=1) > 0
          result<<"."
        end
        n_alt+=1
      when ')' then
        if (paren.size() == 0)
          return nil
        end
        if (n_atom == 0)
          return nil
        end
        while (n_atom-=1)>0
          result<<"."
        end
        while(n_alt>0)
          result<<"|"
          n_alt-=1
        end
        p = paren.pop()
        n_alt = p.n_alt
        n_atom = p.n_atom
        n_atom+=1
      when '*','+','?':
        if (n_atom == 0)
          return nil
        end
        result<<c
      else
        if (n_atom > 1)
          n_atom-=1
          result<<"."
        end
        result<<c
        n_atom+=1
      end
    end
    return nil if paren.size()>0
    while ( (n_atom-=1)> 0)
      result<<"."
    end
    while(n_alt>0)
      n_alt-=1
      result<<"|"
    end
    result
  end
end

使用：

nfa = NFA::compile("a(bb)+a(cdf)*")
assert nfa.test?("abba")
assert nfa.test?("abbbba")
assert !nfa.test?("a")
assert !nfa.test?("aa")
assert nfa.test?("abbacdf")
assert nfa.test?("abbbbacdfcdf")
assert !nfa.test?("bbbbacdfcdf")
assert !nfa.test?("abbbacdfcdf")
assert !nfa.test?("abbbbacdfdf")
assert !nfa.test?("abbbbacdfdfg")

dennis 2008-02-25 17:46 发表评论

位图排序

dennis — Mon, 07 Jan 2008 07:30:00 GMT

    《编程珠玑》第一章第一题就相当的精彩，做个笔记。题目如下：
输入:   一个包含n个正整数的文件，每个正整数小于n,n等于10的7次方（一千万）。并且文件内的正整数没有重复和关联数据。

输出: 输入整数的升序排列

约束：限制在1M左右内存，充足的磁盘空间

    假设整数占32位，1M内存可以存储大概250000个整数，第一个方法就是采用基于磁盘的合并排序算法，第二个办法就是将0-9999999切割成40个区间，分40次扫描（10000000/250000)，每次读入250000个在一个区间的整数，并在内存中使用快速排序。书中提出的第三个解决办法是采用bitmap（或者称为bit vector）来表示所有数据集合（注意到条件，数据没有重复），这样就可以一次性将数据读入内存，减少了扫描次数。算法的伪代码如下：
阶段1：初始化一个空集合
     for i=[0,n)
           bit[i]=0;
阶段2：读入数据i，并设置bit[i]=1
    for each i in the input file
           bit[i]=1;
阶段3：输出排序的结果
   for i=[0,n)
          if bit[i]==1
              write i on the output file

这个算法的时间复杂度在O(n)，用c语言写的版本可以在10秒内完成任务！c语言的源码在该书主页上有，这里给一个java的测试版，加上我的理解注释：

/**
* Created by IntelliJ IDEA.
* User: zhuangxd
* Date: 2008-1-7
* Time: 14:30:44
*/
public class BitSortTest {
    private static final int BITSPERWORD = 32;  //整数位数
    private static final int SHIFT = 5;
    private static final int MASK = 0x1F;  //5位遮蔽 0B11111
    private static final int N = 10000000;
    //用int数组来模拟位数组，总计(1 + N / BITSPERWORD)*BITSPERWORD位，足以容纳N
    private static int[] a = new int[(1 + N / BITSPERWORD)];

    public static void main(String[] args) {
        bitsort(new int[]{1, 100, 2, 10000, 9999, 4567, 78902});
    }

    public static void bitsort(int[] array) {
        for (int i = 0; i < N; i++)
            clr(i);   //位数组所有位清0
        for (int i = 0; i < array.length; i++)
            set(array[i]);   //阶段2
        for (int i = 0; i < N; i++)
            if (test(i))
                System.out.println(i);
    }

    //置a[i>>SHIFT]的第(i & MASK)位为1，也就是位数组的第i位为1
    public static void set(int i) {
        a[i >> SHIFT] |= (1 << (i & MASK));
    }

    //置a[i>>SHIFT]的第(i & MASK)位为0,也就是位数组的第i位为0
    public static void clr(int i) {
        a[i >> SHIFT] &= ~(1 << (i & MASK));
    }

    //测试位数组的第i位是否为1
    public static boolean test(int i) {
        return (a[i >> SHIFT] & (1 << (i & MASK))) == (1 << (i & MASK));
    }
}

dennis 2008-01-07 15:30 发表评论

sicp 3.12 3.13 3.14习题解答

dennis — Thu, 18 Oct 2007 07:56:00 GMT

习题3.12，append不是改变函数，不会改变x的结构。append!是改变函数，显然第一个response是(b)，第二个就是(b c d)。图就不画了，画了一次太麻烦了。

习题3.13,利用set-cdr!形成环，比较有意思：
(define z (make-cycle (list 'a 'b 'c 'd)))

z在DrScheme上表示为：
#0=(a b c d . #0#)

形象地展示了一个环，显然运行(last-pair z)将陷入无限递归，因为(null? (cdr x))永远不会为真。

习题3.14，这道题运行下就知道了，是个倒排list的过程，分析下(mystery v)的运行过程：
(loop (a b c d) '())
(loop (b c d) (a '()))
(loop (c d) (b a))
(loop (d) (c b a))
(loop '() (d c b a))

习题进度落后于读书进度，残念。

dennis 2007-10-18 15:56 发表评论

sicp 3.9题解答

dennis — Mon, 08 Oct 2007 06:55:00 GMT

    引入了赋值之后，代换模型失效，3.2小节引入了环境模型。3.9题用于考察对环境模型的理解。递归版本的(factorial 6)的环境结构如下图：

    blogjava不允许太长的图片，省略了n=3,2,1的三个frame，这些frame的关联环境都是全局环境。
    再看看迭代版本的(factorial 6)的环境结构，同样省去了部分迭代过程，当counter=7的时候迭代停止：

dennis 2007-10-08 14:55 发表评论

一点领悟吧，关于消息传递与lambda算子

dennis — Fri, 03 Aug 2007 01:23:00 GMT

    昨天在读到《Programming Erlang》第8章，开篇点出Erlang是一门纯粹的消息传递风格语言（message passing），我才算是领悟了消息传递。为了这个问题，我还冒昧地去问javaeye上的T1，对这个问题的兴趣是因为SICP第二章以及《失踪的链环》上的介绍。T1给我解答如下：智能能对象只是消息传递的一种具体应用.消息传递说的更为清晰一些就是一种映射关系或者说映射规则.f:a->b;这个规则可以是任意的。我一直将procedural representations of data,也就是sicp中声称intelligent data objects （智能对象）等价于消息传递，而其实智能对象仅仅是消息传递的一种具体应用罢了。
消息传递机制通俗地来讲就是类似于马路上到处投递小广告的投递者，它采取的是Send and Pray策略,既不关心消息是否能精确的传送到真正需要消息的接收者,而是以广播的方式把消息发送给所有人,然后通过回馈来确定消息接收者的类型（引自《失踪的链环》）。因此，动态语言的duct typing是消息传递风格，智能对象是消息传递风格，显然，Erlang的process间的通信机制同样是消息传递风格（Process之间完全通过send message来进行控制和指示，不确定接收方是否具有处理消息的能力，异步的，接收的确认也要等待reply）。
    再来说说lambda算子理论，推荐下g9老大的lambda算子系列文章，这是开篇《lambda算子简介1.a》，以及另外一篇《康托尔、哥德尔、图灵——永恒的金色对角线(rev#2)》。lambda算子理论是函数式编程的理论基础，通过9条公理就可以推到出一个图灵完备的形式系统，其中的Y combinator的推导简直是魔法（为了表示递归），再次领略了计算理论的魅力。另外，最近读sicp第三章《模块化、对象和状态》，也理解了最初的面向对象思想来自何处，在引入了内部状态模拟时间变化之后，对象的最初思想也产生了，同时也带来了赋值导致的Side-Effect，而其实这正是动态OO语言中的对象的理念，通过消息来决定对象的type（ducktyping）。可现代的静态OO语言，在type和clas
之间画上了等号，java里面说一切都是object，其实他想表达的却是一切都是class，通过type以及函数签名等来决定消息的分派(message dispatch)，导致更多的代码集中在消息分派，而不是真正的计算任务上，可以说静态OO已经偏离原始的对象模型很远。
    一点胡思乱想吧，我没有科班经历，所有的东西都是自己在学，在摸索，如有理论和常识上的谬误，请不吝赐教。

dennis 2007-08-03 09:23 发表评论