a*****e
发帖数: 1700 | 1 首先，没有任何 FP 语言是不支持 mutable 的！持有这种观点的，请先去补习一下基
础知识。
鉴别 FP (其实是 declarative)和 imperative 的关键是看它们对 mutability 的区分：
A. every variable is mutable. 多数 duck typed 脚本语言都是这类。
B. mutable by default, immutable by declaration. Java, C, C++ 等勉强属于这类。
C. immutable by default, mutable by declaration. SML, Clojure,
Haskell 属于这类。
然后 B 和 C 都还可以进一步细分，根据 declaration 到底是说变量，还是类型，还
是操作，以下是一些例子。但这之前，有必要先讲讲闭包歧义这个问题：
闭包（Closure）是说将一个函数体里面的非本地变量的值和当前环境（lexical scope
）变量的值做绑定。要弄清楚这里面的语义，在大多数语言里都势必牵涉到一个实现的
问题，就是如果当前环境里一个局部变量如果是 stack allocated，如果它被闭包捕捉
了，那么在退出该环境后，该指向哪里？一个折中的方案是假定闭包捕捉的环境变量的
值都是 pass by value，另一个折中的方案是所有被捕捉的环境变量即便是局部的也要
实现成 heap allocated。这两种方案都有各自的问题，就不细述了。
了解了闭包语义的问题之后，我们来看看几个细分 mutability 的例子：
1. immutable 和 mutable 变量的声明。
Scala 和 Swift 都可以用 val 来声明 immutable value，但这还不是类型上的区分，
所以能力有限，比如无法让一个函数返回一个 mutable 的变量。而且 Scala 和 Swift
里面做闭包都有不同程度的语义问题。
对照 Scheme 和 Clojure，虽然都是 duck type，但 mutable 变量一旦定义了，使用
起来都需要 deref 操作，反而没有闭包歧义。
2. immutable 类型的声明。
C/C++ 里面可以用 const 来声明变量的值不可变，这是反映在类型上的，而且编
译器可以做严格的类型检查，这有一定的好处，但是也有缺陷，因为 const 声明是局
部的限制，而不是追根溯源到原始变量的类型声明，所以同样无法解决闭包的语义问题。
Java 里面可以用 final，但是用处有限。
3. mutable 类型的声明。
在 SML 里面，mutable 的一定是 Ref 类型。所以将 Ref 类型当作 first-class 传递
没有任何问题，而且和 Scheme, Clojure 一样，读取 ref 的值必须通过 deref 操作。
4. mutation 操作的类型声明。
在 Haskell 里面，不光 mutable 的变量要作 IORef 或者 STRef 类型声明，而且任何
mutation 的操作都必须反映到函数类型上。在 Scala 和 SML 里面都不要求这样做，
也没有办法
强制。
所以综上所述，Haskell 是一个极端，immutable by default，强制要求 mutable 类
型，强制从类型上区分 mutation 操作。
从完全不区分 mutability 到全面区分，这中间有各种过渡，不同语言有不同的选择。
通常来讲，凡是不能够很好地区分 mutability 的语言，都有一定程度上的闭包歧义(
比如 js, ruby, perl, python, julia) 或者不便 (比如 C++11)。从语言设计角度来
说，只要是 native 支持 lambda closure，那么不区分 mutability 就是一个愚蠢和
错误的设计。
如果非要得出一个结论，那么不得不说只有 Scheme, Clojure, SML, Haskell 是闭包
语义清晰的 FP 语言，因为他们针对 mutable 变量的操作和 immutable 变量不同，必
须先 deref。这样不用涉及到具体的实现方法，就可以解释清楚闭包的语义，那就是变
量传递 always pass by value，不管是否涉及到闭包。因为 ref 本身也是 value，而
deref 是唯一可以从 ref 取出值的操作。 |
l******t
发帖数: 55733 | |
t**r
发帖数: 3428 | 3 common lisp作为根红苗正的fp 根本没人提 可怜 |
s*i
发帖数: 5025 | 4 没看懂。
计算机概念，如果不能举栗说明，很难讲清楚。
分：
类。
scope
[发表自未名空间手机版 - m.mitbbs.com]
【在 a*****e 的大作中提到】
: 首先，没有任何 FP 语言是不支持 mutable 的！持有这种观点的，请先去补习一下基
: 础知识。
: 鉴别 FP (其实是 declarative)和 imperative 的关键是看它们对 mutability 的区分：
: A. every variable is mutable. 多数 duck typed 脚本语言都是这类。
: B. mutable by default, immutable by declaration. Java, C, C++ 等勉强属于这类。
: C. immutable by default, mutable by declaration. SML, Clojure,
: Haskell 属于这类。
: 然后 B 和 C 都还可以进一步细分，根据 declaration 到底是说变量，还是类型，还
: 是操作，以下是一些例子。但这之前，有必要先讲讲闭包歧义这个问题：
: 闭包（Closure）是说将一个函数体里面的非本地变量的值和当前环境（lexical scope
|
d*******r
发帖数: 3299 | 5 赞干货
大牛说说 SML 主要有什么亮点, 在哪些领域有用呢?
分：
类。
scope
【在 a*****e 的大作中提到】
: 首先，没有任何 FP 语言是不支持 mutable 的！持有这种观点的，请先去补习一下基
: 础知识。
: 鉴别 FP (其实是 declarative)和 imperative 的关键是看它们对 mutability 的区分：
: A. every variable is mutable. 多数 duck typed 脚本语言都是这类。
: B. mutable by default, immutable by declaration. Java, C, C++ 等勉强属于这类。
: C. immutable by default, mutable by declaration. SML, Clojure,
: Haskell 属于这类。
: 然后 B 和 C 都还可以进一步细分，根据 declaration 到底是说变量，还是类型，还
: 是操作，以下是一些例子。但这之前，有必要先讲讲闭包歧义这个问题：
: 闭包（Closure）是说将一个函数体里面的非本地变量的值和当前环境（lexical scope
|
z****e
发帖数: 54598 | 6 说到底就是传递状态
fp里面的func为了避免传递状态
就要求参数immutable
这要求已经很扯蛋了
因为需要你写的时候时刻记着有这么一回事
就是小手说的，看别人传状态你会发疯
其次，对于参数本身也有要求
你说的switch, dispatch, if else这种判断都是强耦合
跟class耦合，任何新增class都会被要求修改源代码
所以fp非常不适合用来做一些class会不断增加减少的场景
最典型如游戏，也就是type会增加会减少
每次增减都会修改源代码，这就很蛋疼了
所以fp一开始就需要对object思考清楚，把所有情况都考虑到
千万不要出现你没有考虑到的object，否则你会不停滴修改源代码
而且每次都会改一堆，所以为了避免这种灾难
干脆全部都搞成map&list算了
反正map&list都没有类似的问题，数据结构简单得不能再简单了
老大爷发的那篇文章其实很有内涵的说 |
z****e
发帖数: 54598 | 7 fp的mutable para/object/var仅限于scope内
一旦超出scope，你的fp就没有意义了
就变得跟class耦合起来，就变得fp不像fp，oop不像oop
四不像，fp很容易写成四不像，然后小手就不停滴发疯
每一个rookie进来之后，都要花很长时间学习这些隐形的限制
而且为什么还非常的抽象，你看有几个能把为社么fp要这样要那样表达清楚的？
几乎每一片都是天书，鸡同鸭讲，皇帝的新衣 |
z****e
发帖数: 54598 | 8 fp的目的是为了复用func
而oop的目的是为了复用object |
a*****e
发帖数: 1700 | 9 你对 FP 一知半解，就不要急着散布假消息了。
【在 z****e 的大作中提到】
: 说到底就是传递状态
: fp里面的func为了避免传递状态
: 就要求参数immutable
: 这要求已经很扯蛋了
: 因为需要你写的时候时刻记着有这么一回事
: 就是小手说的，看别人传状态你会发疯
: 其次，对于参数本身也有要求
: 你说的switch, dispatch, if else这种判断都是强耦合
: 跟class耦合，任何新增class都会被要求修改源代码
: 所以fp非常不适合用来做一些class会不断增加减少的场景
|
z****e
发帖数: 54598 | 10 发信人: sui (黑圈圈), 信区: Programming
标 题: Re: 对 (im)mutability 的误解和深度理解
发信站: BBS 未名空间站 (Thu Feb 12 21:05:43 2015, 美东)
没看懂。
计算机概念，如果不能举栗说明，很难讲清楚。
【在 a*****e 的大作中提到】
: 你对 FP 一知半解，就不要急着散布假消息了。
|
|
|
z****e
发帖数: 54598 | 11 我们举例子分析吧
这样说下去很无聊
【在 a*****e 的大作中提到】
: 你对 FP 一知半解，就不要急着散布假消息了。
|
a*****e
发帖数: 1700 | 12 FP 里面默认变量都是 immutable 并且所有参数传递都是 pass by value。如果需要
mutable 变量，那么可以用一个 1-cell mutable array object 来代替。不能再简单
了吧？这语义理解起来比任何 imperative language 不知道简单多少倍。
反过来，在 imperative 语言里面加入 FP 的 feature, 比如 closure，则会造成语义
不清晰的问题。问一下写 js 或 python 的人多少人真正理解 closure 是怎么读写环
境变量的？十个里面有九个能答错。举例；
http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/
【在 s*i 的大作中提到】
: 没看懂。
: 计算机概念，如果不能举栗说明，很难讲清楚。
:
: 分：
: 类。
: scope
: [发表自未名空间手机版 - m.mitbbs.com]
|
a*****e
发帖数: 1700 | 13 "新增class都会被要求修改源代码"? 错！无论是 haskell 还是 scala 都不需要。
【在 z****e 的大作中提到】
: 我们举例子分析吧
: 这样说下去很无聊
|
z****e
发帖数: 54598 | 14 passed by value什么都是imperative的词汇
declarative用这种表达很过份诶
如果最后理解不得不通过imperative的话
那说明这个人应该天生就适合搞imperative
【在 a*****e 的大作中提到】
: FP 里面默认变量都是 immutable 并且所有参数传递都是 pass by value。如果需要
: mutable 变量，那么可以用一个 1-cell mutable array object 来代替。不能再简单
: 了吧？这语义理解起来比任何 imperative language 不知道简单多少倍。
: 反过来，在 imperative 语言里面加入 FP 的 feature, 比如 closure，则会造成语义
: 不清晰的问题。问一下写 js 或 python 的人多少人真正理解 closure 是怎么读写环
: 境变量的？十个里面有九个能答错。举例；
: http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/
|
z****e
发帖数: 54598 | 15 举例吧，好不好？
【在 a*****e 的大作中提到】
: "新增class都会被要求修改源代码"? 错！无论是 haskell 还是 scala 都不需要。
|
a*****e
发帖数: 1700 | 16 有点强词夺理了。我说 pass by value 是为了熟悉 imperative 语言的人能够理解我
说什么。学 FP 的只说 substitution，将形参替换成实參的值。
【在 z****e 的大作中提到】
: passed by value什么都是imperative的词汇
: declarative用这种表达很过份诶
: 如果最后理解不得不通过imperative的话
: 那说明这个人应该天生就适合搞imperative
|
z****e
发帖数: 54598 | 17 好吧，但我突然发现我们在讨论immutable是啥意思的问题了
你能解释一下为啥需要让变量变成immutable吗？
这么考虑必然有其道理，理由呢？
【在 a*****e 的大作中提到】
: 有点强词夺理了。我说 pass by value 是为了熟悉 imperative 语言的人能够理解我
: 说什么。学 FP 的只说 substitution，将形参替换成实參的值。
|
a*****e
发帖数: 1700 | 18 Haskell 例子：
data Rating = Best | Better | Good | Bad | Worse | Worst
instance Show Rating where
show Best = "*****"
show Better = "****"
show Good = "***"
show Bad = "**"
show Worse = "*"
show Worst = "(zero star)"
这里我定义了一个新类型 Rating 以及它的 Show class instance。任何地方用到
show 的，都会调用我这个代码。比如标准库里面定义了 print x = putStrLn (show x
) 这个函数，它的类型是 Show a => a -> IO ()，我不需要回头去修改标准库，就可
以直接使用 print Best，结果是输出五颗星到 stdout。这个不算 extensible 那我还
真不知道什么是 extensible 了。
【在 z****e 的大作中提到】
: 举例吧，好不好？
|
a*****e
发帖数: 1700 | 19 我觉得你不妨反过来考虑一下，为啥让变量变成 mutable?
解释 mutable 必须引入一个 memory 或者 store 或者 heap 的概念，什么在一个 box
里面写个字啦，擦掉它又写个新的字啦，诸如此类。
而将变量替换为值则是一个非常基础的代数概念，有中学水平的都能够理解。这足够解
释 FP 的语义。如果需要 mutable，引入 heap allocated mutable object 即可，没
必要必须要让变量成为 mutable，没必要让 mutable 变量进入核心语义，干扰其他概
念的理解（比如闭包，具体例子我上面给了 http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/ ）
【在 z****e 的大作中提到】
: 好吧，但我突然发现我们在讨论immutable是啥意思的问题了
: 你能解释一下为啥需要让变量变成immutable吗？
: 这么考虑必然有其道理，理由呢？
|
z****e
发帖数: 54598 | 20 那别人这个时候用了 print x = putStrLn (show x) 这个函数
突然显示的就不是Best这些东西了，而是stars了？
他用的时候知道吗？你怎么确保他知道呢？
【在 a*****e 的大作中提到】
: Haskell 例子：
: data Rating = Best | Better | Good | Bad | Worse | Worst
: instance Show Rating where
: show Best = "*****"
: show Better = "****"
: show Good = "***"
: show Bad = "**"
: show Worse = "*"
: show Worst = "(zero star)"
: 这里我定义了一个新类型 Rating 以及它的 Show class instance。任何地方用到
|
|
|
z****e
发帖数: 54598 | 21 因为可以复用变量啊
就是复用object啊
这里面可能有一部分是为了节省内存考虑
box
【在 a*****e 的大作中提到】
: 我觉得你不妨反过来考虑一下，为啥让变量变成 mutable?
: 解释 mutable 必须引入一个 memory 或者 store 或者 heap 的概念，什么在一个 box
: 里面写个字啦，擦掉它又写个新的字啦，诸如此类。
: 而将变量替换为值则是一个非常基础的代数概念，有中学水平的都能够理解。这足够解
: 释 FP 的语义。如果需要 mutable，引入 heap allocated mutable object 即可，没
: 必要必须要让变量成为 mutable，没必要让 mutable 变量进入核心语义，干扰其他概
: 念的理解（比如闭包，具体例子我上面给了 http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/ ）
|
a*****e
发帖数: 1700 | 22 别人用到 print 这个函数，作用于 Rating 类型的参数时，的确会打印星号。首先，
他要用到 Rating 类型，必须 import 我的定义到当前 scope，如果我的类型定义和
instance 定义写在一个 module 里，相当于他也用到了我关于 show 的定义。如果我
把类型定义和 instance 定义分开写在两个 module 里面，他可以只 import 前者，然
后自行定义 show。不干扰。
【在 z****e 的大作中提到】
: 那别人这个时候用了 print x = putStrLn (show x) 这个函数
: 突然显示的就不是Best这些东西了，而是stars了？
: 他用的时候知道吗？你怎么确保他知道呢？
|
z****e
发帖数: 54598 | 23 举个例子
游戏里面，同一个物体会不停滴有各种状态
最简单的，一架灰机飞过地图
x,y是其坐标，那(x,y)就是一个变量组合
那每一ms我们刷新一次的话
1s之后，就会爆出1000个内存块
随着游戏中物体的不断增加
这个增长会有些太过于快了点吧？
如果是mutable的话，就很容易了
直接修改原值就好了
box
【在 a*****e 的大作中提到】
: 我觉得你不妨反过来考虑一下，为啥让变量变成 mutable?
: 解释 mutable 必须引入一个 memory 或者 store 或者 heap 的概念，什么在一个 box
: 里面写个字啦，擦掉它又写个新的字啦，诸如此类。
: 而将变量替换为值则是一个非常基础的代数概念，有中学水平的都能够理解。这足够解
: 释 FP 的语义。如果需要 mutable，引入 heap allocated mutable object 即可，没
: 必要必须要让变量成为 mutable，没必要让 mutable 变量进入核心语义，干扰其他概
: 念的理解（比如闭包，具体例子我上面给了 http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/ ）
|
a*****e
发帖数: 1700 | 24 你知道 SSA 吗？LLVM 编译 C/C++ 到 SSA form，里面的变量都是 immutable 的，只
有 heap 和 stack 是 mutable 的，完全不妨碍实现任何功能。
所以你说这些，用 mutable heap object 在 FP 里面都直接做，难度在哪里？
【在 z****e 的大作中提到】
: 举个例子
: 游戏里面，同一个物体会不停滴有各种状态
: 最简单的，一架灰机飞过地图
: x,y是其坐标，那(x,y)就是一个变量组合
: 那每一ms我们刷新一次的话
: 1s之后，就会爆出1000个内存块
: 随着游戏中物体的不断增加
: 这个增长会有些太过于快了点吧？
: 如果是mutable的话，就很容易了
: 直接修改原值就好了
|
z****e
发帖数: 54598 | 25 做起来不难，这个增长是不是有些惊人呢？
【在 a*****e 的大作中提到】
: 你知道 SSA 吗？LLVM 编译 C/C++ 到 SSA form，里面的变量都是 immutable 的，只
: 有 heap 和 stack 是 mutable 的，完全不妨碍实现任何功能。
: 所以你说这些，用 mutable heap object 在 FP 里面都直接做，难度在哪里？
|
a*****e
发帖数: 1700 | 26 GHC 的作者 SPJ 的名言 Haskell is the best imperative language，不是更惊人？
FP 写的 commercial game 都有，比如 Naughty Dog 以前规模尚小的时候，都是用自
己的 Lisp 实现在写 console game，一样大卖。
【在 z****e 的大作中提到】
: 做起来不难，这个增长是不是有些惊人呢？
|
z****e
发帖数: 54598 | 27 我相信有一样大卖的东西
因为它可以改成mutable的var
不过那样的话，跟oop又有啥太大区别呢？
那你的意思就是这个是fp和oop的主要差别是不？
虽然我不怎么在乎内存的使用，但是immutable还是不用了
这个太夸张了
当然除非有限的状态集
但是这个也有enum来搞，enum应该就是immutable的一种吧?
【在 a*****e 的大作中提到】
: GHC 的作者 SPJ 的名言 Haskell is the best imperative language，不是更惊人？
: FP 写的 commercial game 都有，比如 Naughty Dog 以前规模尚小的时候，都是用自
: 己的 Lisp 实现在写 console game，一样大卖。
|
a*****e
发帖数: 1700 | 28 我知道你理解的差距在哪里了，你以为 FP 不支持 mutability，其实 FP 只是（倾向
于）不支持 mutable variable 而已。Haskell 里面特地用 ST monad 支持 mutable
array 实现，和 imperative language 里面的 mutable array 完全没区别啊
【在 z****e 的大作中提到】
: 做起来不难，这个增长是不是有些惊人呢？
|
z****e
发帖数: 54598 | 29 这个应该是你主贴说的东西吧
我觉得主要差距是lambda，1st class citizen
immutable我觉得不用纠结
【在 a*****e 的大作中提到】
: 我知道你理解的差距在哪里了，你以为 FP 不支持 mutability，其实 FP 只是（倾向
: 于）不支持 mutable variable 而已。Haskell 里面特地用 ST monad 支持 mutable
: array 实现，和 imperative language 里面的 mutable array 完全没区别啊
|
a*****e
发帖数: 1700 | 30 你如果转而谈论 immutable data structure，那是一个不同的问题，和所有的 data
structure 设计一样，immutable data structure 有它适用的场景（比如实现
persistency），也有它不适用的场景（比如反复 allocation 是一种浪费）。在恰当
的环境下选用恰当的 data structure，无论你用什么语言，都是必须的。
但从语言设计的角度，根本不是什么 immutable data structure 的问题，就是
mutable variable vs immutable variable 的问题，或者进一步说，是 mutability
是否应该反映到 type 层面的问题。
【在 z****e 的大作中提到】
: 我相信有一样大卖的东西
: 因为它可以改成mutable的var
: 不过那样的话，跟oop又有啥太大区别呢？
: 那你的意思就是这个是fp和oop的主要差别是不？
: 虽然我不怎么在乎内存的使用，但是immutable还是不用了
: 这个太夸张了
: 当然除非有限的状态集
: 但是这个也有enum来搞，enum应该就是immutable的一种吧?
|
|
|
a*****e
发帖数: 1700 | 31 lisp 方言太多，提一下 scheme 把意思弄到了就好了，是吧
【在 t**r 的大作中提到】
: common lisp作为根红苗正的fp 根本没人提 可怜
|
a*****e
发帖数: 1700 | 32 我在另外的贴子举了个例子 ocaml 写的 unikernel MirageOS，你可以看看。
SML 本身因为 compiler 和 community 的问题，一直只是作为 teaching language 的
存在。反而是 OCaml 作为 ML 的变种，发展得不错，用得比较多，而且用得多的都是
它 ML 那一面，不是 OO 那一面。
【在 d*******r 的大作中提到】
: 赞干货
: 大牛说说 SML 主要有什么亮点, 在哪些领域有用呢?
:
: 分：
: 类。
: scope
|
z****e
发帖数: 54598 | 33 不是呀
我觉得这样无限度滴使用immutable显然是不对的
你看这样
class->mutable, enum->immutable
你觉得好不好呢？
【在 a*****e 的大作中提到】
: 你如果转而谈论 immutable data structure，那是一个不同的问题，和所有的 data
: structure 设计一样，immutable data structure 有它适用的场景（比如实现
: persistency），也有它不适用的场景（比如反复 allocation 是一种浪费）。在恰当
: 的环境下选用恰当的 data structure，无论你用什么语言，都是必须的。
: 但从语言设计的角度，根本不是什么 immutable data structure 的问题，就是
: mutable variable vs immutable variable 的问题，或者进一步说，是 mutability
: 是否应该反映到 type 层面的问题。
|
a*****e
发帖数: 1700 | 34 注意是将 mutability 反映到 type 层面，而不是无限度适用 immutable 啊～～～
【在 z****e 的大作中提到】
: 不是呀
: 我觉得这样无限度滴使用immutable显然是不对的
: 你看这样
: class->mutable, enum->immutable
: 你觉得好不好呢？
|
z****e
发帖数: 54598 | 35 default是immutable显然是有问题的
这样的话，heap很快就会被占满，然后触发大gc
gc停顿已经经常为人所诟病了，你这样搞的话，那gc会经常性停顿
fp实在是一个比oop更为凶狠的角色
如果fp要发达，除非你能把状态集控制在一个有限的范围内
immutable还是不用了，不纠结了，lilip那贴说得多好啊
lambda什么理解了，immutable之类的不用纠结
怎么想还就是那么一回事 |
z****e
发帖数: 54598 | 36 那这就是一种限制不是，又得多加留意了
【在 a*****e 的大作中提到】
: 注意是将 mutability 反映到 type 层面，而不是无限度适用 immutable 啊～～～
|
a*****e
发帖数: 1700 | 37 我建议你仔细深入学习下一为什么 imperative language 里加入 closure 会有各种问
题：
http://eev.ee/blog/2011/04/24/gotcha-python-scoping-closures/
【在 z****e 的大作中提到】
: default是immutable显然是有问题的
: 这样的话，heap很快就会被占满，然后触发大gc
: gc停顿已经经常为人所诟病了，你这样搞的话，那gc会经常性停顿
: fp实在是一个比oop更为凶狠的角色
: 如果fp要发达，除非你能把状态集控制在一个有限的范围内
: immutable还是不用了，不纠结了，lilip那贴说得多好啊
: lambda什么理解了，immutable之类的不用纠结
: 怎么想还就是那么一回事
|
a*****e
发帖数: 1700 | 38 另外对于使用 GC 的语言，显然使用 immtuable by default 更适合 generational GC
，因为在 older generation 的 live object 如果是 immutable 的，它们不会再指
向 younger generation 的 object，扫描起来只需要考虑 young generation 到 old
generation 的指针，方便很多。
当然 Haskell 的情况略特殊，不细谈了，只说一句 GHC 的 Generational Parallel
GC with private heap 基本是黑科技，我们组里搞了 20 年的 GC 专家都做不到它的
效率。
【在 z****e 的大作中提到】
: default是immutable显然是有问题的
: 这样的话，heap很快就会被占满，然后触发大gc
: gc停顿已经经常为人所诟病了，你这样搞的话，那gc会经常性停顿
: fp实在是一个比oop更为凶狠的角色
: 如果fp要发达，除非你能把状态集控制在一个有限的范围内
: immutable还是不用了，不纠结了，lilip那贴说得多好啊
: lambda什么理解了，immutable之类的不用纠结
: 怎么想还就是那么一回事
|
z****e
发帖数: 54598 | 39 你说的适合gc是gc起来更容易一点
但是本身也会导致gc次数更为频繁
甚至可以说是频繁得多得多
所以不能只对比一次gc的效率
应该把gc频率也算进去
GC
old
【在 a*****e 的大作中提到】
: 另外对于使用 GC 的语言，显然使用 immtuable by default 更适合 generational GC
: ，因为在 older generation 的 live object 如果是 immutable 的，它们不会再指
: 向 younger generation 的 object，扫描起来只需要考虑 young generation 到 old
: generation 的指针，方便很多。
: 当然 Haskell 的情况略特殊，不细谈了，只说一句 GHC 的 Generational Parallel
: GC with private heap 基本是黑科技，我们组里搞了 20 年的 GC 专家都做不到它的
: 效率。
|
z****e
发帖数: 54598 | 40 还有一点
对于immutable的目的没有表述出来
因为如果不设置成immutable
在多线程的环境中
就会出现不确定性
那就是输入一致的时候，输出不同
同一个东西有可能出现两种结果
所以干脆全部弄成immutable的，不让你改
所以为了保证这一点
每一次出现新的value，都需要重新生成一个新的变量
这个真心不适合一些特别活跃的物体
适合数字文本处理这些，能够赋值一次，走完整个生命周期
然后销毁，不过这个确定性也可以挪用到其他地方去
oop也可以做成这样，无非包多一层，不要用static var就好了
但是oop一般不要求你做成immutable的，所以不同的状态下
有可能函数结果不同，但是这个东西无非是一个留意嘛
也就是说做成immutable容易搞嘛，oop其实也可以这么做
但是immutable对于那种状态非常活跃的对象，十分不合适啊
需要声明其为mutable heap object，而这么做的话
就不能绝对保证多线程环境下的确定性了，就不是pure fp了
我相信这种东西还是会出现的，比如游戏，游戏实在是不适合做fp
越是即时的越不合适，batch倒是比较适合immutable
发信人: coltzhao (coltzhao), 信区: Programming
标 题: Re: oop还是跟fp是对立的
发信站: BBS 未名空间站 (Thu Feb 12 13:41:50 2015, 美东)
the good about OO is its encapsulation, the bad of OO is the dynamic part (
including inheritance, polymorphism etc.)
For internal state, if you want to use it in parallel/distributed env, you
will have to make it explicit to outside, or just make it immutable anyway. |
|
|
k****i
发帖数: 101 | 41 阿尺开讲，赞！所提到的闭包问题简例：
# semantically ambiguous closure in ls
[f 3 for f in [(+ x) for x in [1 2]]] #[5,5]
# wrapped version to disambiguation in ls
[f 3 for f in [((x) -> (+ x)) x for x in [1 2]]] #[4,5]
-- canonical closure in hs
[f 3 | f <- [(+ x) | x <- [1,2]]] --[4,5]
分：
类。
scope
【在 a*****e 的大作中提到】
: 首先，没有任何 FP 语言是不支持 mutable 的！持有这种观点的，请先去补习一下基
: 础知识。
: 鉴别 FP (其实是 declarative)和 imperative 的关键是看它们对 mutability 的区分：
: A. every variable is mutable. 多数 duck typed 脚本语言都是这类。
: B. mutable by default, immutable by declaration. Java, C, C++ 等勉强属于这类。
: C. immutable by default, mutable by declaration. SML, Clojure,
: Haskell 属于这类。
: 然后 B 和 C 都还可以进一步细分，根据 declaration 到底是说变量，还是类型，还
: 是操作，以下是一些例子。但这之前，有必要先讲讲闭包歧义这个问题：
: 闭包（Closure）是说将一个函数体里面的非本地变量的值和当前环境（lexical scope
|
b***e
发帖数: 17 | 42 Javascript没有immutable，也没有什么歧义，虽然确实有的时候令人费解。
有一片文章是专门讨论SML和Haskell里面deref的含义的，并且由此引出了一个形式化
的pure的定义。很有意思。有兴趣可以读一读。
http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=9CA80D
Roughly, if (deref a) is not further reducible, then it's purely functional.
Otherwise, if (deref a) can be further reduced to another value, then it
is impure. In pure languages, such as Haskell, the reduction of (deref a)
is at a second pass of interpretation (monadic interpretation). 所以Haskell
的语义和别的语言不一样的地方在于它有两层semantics，第一层是pure functional的
，第二层是monadic的。
分：
类。
scope
【在 a*****e 的大作中提到】
: 首先，没有任何 FP 语言是不支持 mutable 的！持有这种观点的，请先去补习一下基
: 础知识。
: 鉴别 FP (其实是 declarative)和 imperative 的关键是看它们对 mutability 的区分：
: A. every variable is mutable. 多数 duck typed 脚本语言都是这类。
: B. mutable by default, immutable by declaration. Java, C, C++ 等勉强属于这类。
: C. immutable by default, mutable by declaration. SML, Clojure,
: Haskell 属于这类。
: 然后 B 和 C 都还可以进一步细分，根据 declaration 到底是说变量，还是类型，还
: 是操作，以下是一些例子。但这之前，有必要先讲讲闭包歧义这个问题：
: 闭包（Closure）是说将一个函数体里面的非本地变量的值和当前环境（lexical scope
|
f******x
发帖数: 98 | 43 赞一下LZ,解释得清楚明了，有理有据有例有力。 |
n******n
发帖数: 12088 | 44 反人类的语法。
【在 k****i 的大作中提到】
: 阿尺开讲，赞！所提到的闭包问题简例：
: # semantically ambiguous closure in ls
: [f 3 for f in [(+ x) for x in [1 2]]] #[5,5]
: # wrapped version to disambiguation in ls
: [f 3 for f in [((x) -> (+ x)) x for x in [1 2]]] #[4,5]
: -- canonical closure in hs
: [f 3 | f <- [(+ x) | x <- [1,2]]] --[4,5]
:
: 分：
: 类。
|
c*******9
发帖数: 9032 | 45 目前游戏多是模似现实的，现实就是一种假象，所以用mutable这种假想楖念更方便。
真像是＂人不可能两次通过同一条河＂。
【在 z****e 的大作中提到】
: 还有一点
: 对于immutable的目的没有表述出来
: 因为如果不设置成immutable
: 在多线程的环境中
: 就会出现不确定性
: 那就是输入一致的时候，输出不同
: 同一个东西有可能出现两种结果
: 所以干脆全部弄成immutable的，不让你改
: 所以为了保证这一点
: 每一次出现新的value，都需要重新生成一个新的变量
|
