对Haskell这门语言的基本认识

Haskell语言的核心特征：

1. 函数式，而且是纯函数式(purely functional)

首先，引用一下维基百科上对“典型的函数式编程语言”的划分：

　　　　一： 纯函数式

　　　　　 1. 强静态类型： Miranda , Haskell

　　　　　 2. 弱类型： Lazy K

　　　　二:  非纯函数式

　　　　　 1. 强静态类型:  ML家族（包括OCaml , F#）， Scala

　　　　　 2. 强动态类型：Lisp家族（包括Comon Lisp,Scheme, Clojure)， Erlang

　　　　　 3. 弱类型：Unlambda

考虑到Haskell自一出生起就替代了Miranda，实际上Haskell就是现在唯一一门还算使用者比较多的纯函数式编程语言。

而“纯”函数式的好处就是：

　　a. 引用透明 (Referential Transparency) :

　　　即无论何时调用一个函数，对于相同的输入总产生相同的输出

　　b. 无副作用 (Side-effect free) :

　　　不存在函数的执行过程中偷偷修改了一个全局状态而从函数类型签名上看不出来的情况。（副作用是现在很多OOP语言里Bug的根源）

　　　当然，不是说Haskell里无法表达副作用，副作用，比如IO，肯定是要有这种能力的。而是说Haskell通过 Monad（中文译为: 单子）这种手法，把副作用体现在类型签名上。

函数式编程相较于面向对象编程很大的不同就是一种思维方式上的变化：

　　面向对象编程OOP中，貌似更关注于“数据及它们的行为”：我们把程序表现为 一堆数据（对象objects），并通过使用对象提供的接口来访问这些数据。

　　函数式编程FP中，关注点更着眼于“数据及它们的流动处理”： 就像数学函数的连续运算一样。

而Haskell有了'pure'的特点以后，就更有利于进行 函数的“组合(composition)” 了： 因为函数都是“引用透明的”，所以真正发生计算的顺序就不重要了，这使得我们进行函数组合时更加得心应手。（如果存在副作用的话，那么 函数f -> 函数g 两个函数依次调用时，先计算f 还是先计算g 是很不一样的！因为f,g 内部可能都带有全局的副作用）

使用Haskell编程总时不时有这种感觉：函数就像“水管”，而数据就像水管中的“水”，而我们所做的就是把不同的水管“首尾拼接起来”（其中每一段水管只完成特定的小工作）， 从而完成对数据的复杂的处理。

比如：

-- 写一个函数，将制定的数组中的数字全部乘以2，然后统计其中大于100的数字的个数
f :: [Int] -> Int
-- f arr = length . filter (> ) $ map (* ) arr
f = length . filter (> ) . map (* )    -- 可以进一步省略参数（这其实就是lambda演算中的 Eta转换, 也可以称为 point-free风格）

我们先对 arr 进行 map (* 2)  ——> 再 filter (> 100) ——> 最后统计length个数 ， 一行代码即可、毫无废话、极其简洁！（想想Java 8 以前的话该怎么写。。。)

　　 　　　　

2. 静态类型(statically typed)，支持自动类型推导(type inference)

这个特点就不多说了。

Haskell的类型系统是基于著名的 Hindley-Miller类型系统（和ML家族的语言一样），并进行了一些扩展（如typeclass）。

从表现上看就是每个函数可自行选择添加类型签名（type signature/ contract, 一般建议都写，是很好的编程习惯），而函数体中完全不出现任何类型。

3. 惰性求值(lazy evaluation)

这其实是一种函数调用时的传参策略。

一般的传参策略包括：

　　1. call by value (按值调用) :  即形参对象其实是实参对象的拷贝副本，二者不是同一个对象，函数体内对形参的修改不影响外部的实参对象。Java 中的基本类型都是按值调用的。

　　2. call by reference (按引用调用) : 即形参对象和实参对象是同一个对象，拷贝的其实是一个对象的地址。 这在C++中很容易体现，Java中的引用类型都是按引用调用的。

注意，上述策略中实参都会被计算完成，比如 f (g(x)); 这个调用，肯定是先计算 g(x)得到一个值val，然后调用 f(val)

而对于惰性求值来讲，g(x) 不必进行计算！直到 f 函数体内真正使用这个 g(x)对应的形参变量时、g(x)才会被计算！

　　3. 惰性求值又支持两种策略： call by name (按名调用) 和 call by need (按需调用) 。 区别是后者比前者多一个 memorization的过程，即一旦一个表达式被求值了，就会保存该结果、避免再次使用该值时的反复求值。

Haskell是 call by need.

4. 其他

比如 代数数据类型ADT、模式匹配、typeclass （类似于Java中的Interface）和多态类型。

尤其是模式匹配，实在是太好用了！

另外的什么  List Comprehension啥的不过是简单的语法糖，倒也没什么。

---

加一些可以扩展理解的材料吧：

1. 王垠 ：  <不再推荐Haskell> :