Haskell语言学习笔记（2）

comments（注释）

• 单行注释用 --
  x = 5 -- The variable x is 5.
• 多行注释用 {- ... -}
  x = {- Do this just because you can. -} 5

variables（变量）

• 变量的值一旦绑定就不再发生变化。
  
• 变量中存放的与其说是值，不如说是表达式。（惰性求值）
  

逻辑运算

	equal to	not equal to	and	or	not	true	false
Haskell	==	/=	&&	||	not	True	False
C/C++	==	!=	&&	||	!	true	false

guards & where

-- ax2 + bx + c = 0 求解的个数
numOfSolutions a b c
    | disc > 0  = 2
    | disc == 0 = 1
    | otherwise = 0
        where
        disc = b^2 - 4*a*c

type signature（类型签名）

Haskell	C++
xor :: Bool -> Bool -> Bool xor p q = (p || q) && not (p && q)	bool xor(bool p, bool q) {     return (p || q) && !(p && q); }

Maybe类型

Maybe类型是一种参数化的可空类型，在语言中用来表示可有可无这种概念（也就是0个或1个）。

Haskell	C++	C#	Java8
Maybe	boost::optional<T>	Nullable<T>	Optional<T>

Maybe类型，主要有以下几种应用：

• 作为数据的类型，表示该数据可有可无，在数据为空时可起到其他语言中空指针（或空引用）的作用。
• 作为函数的参数类型，表示该参数可有可无，起到可选参数的作用。
• 作为函数的返回值类型，表示返回值可有可无，可以避免在没有合适的返回值时返回特殊值（比如 -1 ）或者报运行时错误。

Either类型

Either 类型与 Maybe 类型一样也可以表示一种可能失败的计算。但与 Maybe 类型有所不同的是，Either类型可以在失败时保存失败信息。

list（列表）

• 列表为大小可变，成员类型相同的数据结构，使用中括号。
• 在Haskell语言中字符串被看做字符的列表。
• (:)运算符连接成员与列表，(++)运算符拼接两个列表。

tuple（元组）

• 元组为大小固定且有序的数据结构，使用小括号。成员类型无须相同，成员的类型和顺序决定元组的类型。
• 元组本身没有名字，成员也没有名字。
• 不存在只有一个成员的元组。没有任何成员的元组记作()。

type variable（类型变量）

Haskell	C++
fst :: (a, b) -> a	template<typename A, typename B> A fst(const pair<A, B>&);

if-then-else & pattern matching

-- if-then-else
mySignum x =
    if x < 0 then -1
    else if x > 0 then 1
    else 0
-- patten matching
mySignum2 x
    | x < 0 = -1
    | x > 0 = 1
    | otherwise = 0

typeclass（类型类）

-- 加号这个函数带两个a类型的参数，返回一个a类型的值。其中a类型属于Num类型类。
(+) :: (Num a) => a -> a -> a

let ... in

-- ax2 + bx + c = 0 求解
roots a b c =
    let sdisc = sqrt (b*b - 4*a*c)
        twice_a = 2*a
    in  ((-b + sdisc) / twice_a,
         (-b - sdisc) / twice_a)

dot dot notation（点点记法）

[1..10]          [1,2,3,4,5,6,7,8,9,10]
[2,4..10]        [2,4,6,8,10]
[5,4..1]         [5,4,3,2,1]
[1,3..10]        [1,3,5,7,9]
[1..]            [1,2,3,4,...]
['a'..'z']       "abcdefghijklmnopqrstuvwxyz"

case ... of

// 分段函数
f 0 = 18
f 1 = 15
f 2 = 12
f x = 12 - x
// case of
f x = case x of
    0 -> 18
    1 -> 15
    2 -> 12
    _ -> 12 - x

{} 和 ;

bar = let a = 1
          b = 2
          c = 3
      in a + b + c

foo = let { a = 1;  b = 2;
        c = 3 }
      in a + b + c

module 导入导出

module SimpleJSON(JValue(..), getString) where

module ExportEverything where

module ExportNothing () where

module PrettyJSON(renderJValue) where
import Numeric (showHex)
import SimpleJSON (JValue(..))