最近入了本SICP，发现自己对Lisp没以前那么反感了……好像括号看起来还不错……

starwing83

回复 55# OwnWaterloo


    你的结论呢？我觉得稍微装装也不算啥，就事论事的话，他也有很牛的地方。对于共事来说，你的想法呢？

其实我觉得吧，他又不是做学问的，偶尔装装，也是可以理解的嘛= =比起老谭之流，至少还是好多了的。

starwing83

回复 61# OwnWaterloo


    你真的确定这个写法能过编译？？？？

1. foldr' F id bs = \y -> foldl f y bs
   
2.     where F = \b g x -> g $ f x b
   

复制代码

我这边不能上外网，麻烦给个正确的示例，我再想想～

starwing83

回复 63# OwnWaterloo


    不能访问。SICP对面向对象（或者说ADT，或者说名字空间，或者说代码组织，或者说模块封装）有十分独特的看法，让人觉得耳目一新，我要不要发个贴讲解一下？

starwing83

回复 63# OwnWaterloo


    擦……回错了……重回

    关于foldr转foldl的我搞清楚了。这里说明一下。首先，我们有：

1. 
   
2. foldr' f i [] = i
   
3. foldr' f i (x:xs) = f x (foldr' f i xs)
   

复制代码

当定义foldl‘’的时候，我们有：

1. 
   
2. foldl'' f i xs = foldr' (\b g x -> g (f x b)) id xs i

复制代码

首先我们知道，foldl的功能是对f和i，[x1, x2, ... , xn], 产生这样的计算过程：

1. 
   
2. ( ... ((i `f` x1) `f` x2) ... ) `f` xn)

复制代码

而foldr是产生这么一个计算过程：

1. 
   
2. (x1 `f` (x2 `f` ( ... ( xn `f` i)) ... )

复制代码

从foldr的定义中可以很清楚的看到这种转换。

现在我们看用foldr的那个定义是如何处理的。首先用`f`计算xn和i：

1. 
   
2.     (\b g x -> g(f x b)) xn id
   
3. --> (\     x -> id (x `f` xn))
   
4. --> (\x -> x `f` xn)

复制代码

由此可知，我们将xn放到了右边，并延缓了计算（直到给出x为止）
然后我们以这个函数、给出的函数和xn-1计算新的值：

1. 
   
2.   (\b g x -> g (f x b)) xn-1 (\x -> x `f` xn)
   
3. --> (\ x -> (\x -> x `f` xn) (x `f` xn-1))
   
4. --> (\x  -> ((x `f` xn-1) `f` xn))

复制代码

一样的过程，将xn-1插入到了xn之前，并延缓执行。

以此类推，最后的结果就是将计算按照foldl的方式安排好了，但是所有的计算都被延缓了。

最后，给出一个初始值i，启动整个计算，这个计算就是foldl的了。

问题是：
1. 展开的时候，有没有栈的问题？会不会有无穷展开导致编译错误的情况？
2. 这种延缓的执行启动的时候，是否是in-place执行的？就和foldl一样？
3. foldr本身是延缓执行的。它能不能通过参数调整的方式做到in-place执行？比如，先执行最后一个，然后逐次向前迭代，做到in-place？
4. 最后，Haskell有没有尾调用？Haskell的优化可以保证到什么程度？在逻辑上有迭代执行的可能性的时候，Haskell是不是一定可以迭代执行？

starwing83

回复 67# pandaiam


    亚马逊搜一下把，直接搜sicp

starwing83

回复 69# OwnWaterloo


    SCIP在没有引入赋值的基础上就导出了类型系统哦～（不是OO）

starwing83

回复 70# OwnWaterloo


    31.5，贵么？

starwing83

回复 73# pandaiam

1. local function dfs(t, idx)
   
2.     if t.equals == t.result then error "ok" end
   
3. 
   
4.     local idx = idx or 1
   
5.     local cur = t[idx]
   
6.     if cur == t.len then
   
7.         t.equals = t.equals + 1
   
8.         dfs(t, idx + 1)
   
9.         t.equals = t.equals - 1
   
10.         return
    
11.     end
    
12. 
    
13.     for i = #t, idx+1, -1 do
    
14.         local res = cur + t[i]
    
15.         if res <= t.len then
    
16.             t[i] = res
    
17.             dfs(t, idx + 1)
    
18.             t[i] = t[i] - cur
    
19.         end
    
20.     end
    
21. end
    
22. 
    
23. local function solve(t)
    
24.     -- find the posible length
    
25.     table.sort(t)
    
26.     t.max = t[#t]
    
27.     t.sum = 0
    
28.     for i, v in ipairs(t) do t.sum = t.sum + v end
    
29.     for i = t.max, t.sum do
    
30.         t.result = t.sum/i
    
31.         if t.result == math.floor(t.result) then
    
32.             t.equals = 0
    
33.             t.len = i
    
34.             if not pcall(dfs,t) then return i end
    
35.         end
    
36.     end
    
37. end
    
38. 
    
39. print(solve {5,2,1,5,2,1,5,2,1,6})
    
40. print(solve {2,3,5,7,11,13,17,19,23})
    
41. print(solve {1,2,3,4})
    
42. 
    
43. 
    

复制代码

starwing83

回复 74# OwnWaterloo


    不大容易，因为要归纳还有点难度。

话说回来把。我觉得haskell和lisp一样都是一种毒品。一旦你习惯了list/curry，再去看C/C++，真是很痛苦的事情，你会觉得自己被限死在一套框子里面出不来的感觉。以前对机器的直觉感觉越来越模糊了。都快记不得CPU，RAM，寄存器，跳转，堆栈这些东西了，脑海中就只有变换，计算这些，感觉是两个世界的存在，一个是机械世界，一个是生物世界。

starwing83

回复 78# OwnWaterloo


    不是说重要，也不是说好，但是，你不觉得那种直觉更真实么，特别是haskell，给我一种，恩，在念自己不懂原理的魔咒那种很没有安全感的感觉。我根本不知道编译器会在什么时候跟我抱怨，而C/C++我是知道的。