real world haskell -读书笔记

Prelude> :type map
map :: (a -> b) -> [a] -> [b]

• -> 右结合 所以 (a -> b) -> [a] -> [b] == ((a -> b) ->( [a] -> [b]))
• (a->b) 输入为a类型,返回b类型的函数A;
• ( [a] -> [b])) 输入为[a]类型,返回[b]类型的函数B;
• ((a -> b) ->( [a] -> [b])) 输入为函数A,返回为函数B
• 至此map就是一个输入为函数A,返回为函数B的函数.

实例: map (\(x) -> x*2) [1,2] == (map (\(x) -> x*2)) [1,2] 加上函数的currying上面的就好理解了.

oop容易跌入状态同步的泥潭,fp容易跌入函数传来传去的泥潭


Char -> 'a'
String -> "aaaa" === ['a','a','a','a'] / [Char]

list -> [] 不固定长度,同类型.
Tuple -> ("asdf",1,2,4) 初始化好后不可改变.

函数调用左集合 a b c d = (((a b) c) d)

x = 10
x = 11 can't 不能两次给变量赋值 除了类型推导,怎么越看越像erlang,

:type take
 take::Int -> [a] -> [a]  === take:Int -> ([a]->[a])

currying

take 3 [1,2,4,5] 看似多参数,其实是:((take 3) [1,2,,4,5]) = [1,2,4]

Defining a New Data Type

  haskell 原生的也就是list,tuple (erlang也一样).但是haskell可自己定义data type.erlang只能用装成record的tuple.

haskell玩来玩去骨子里也是tuple,但是他封装的好,有类型,有模有样.比erlang强太多.


-------foldl,foldr--------

foldl (+) 0 (1:2:3:[])
          == foldl (+) (0 + 1)             (2:3:[])
          == foldl (+) ((0 + 1) + 2)       (3:[])
          == foldl (+) (((0 + 1) + 2) + 3) []
          ==           (((0 + 1) + 2) + 3)


foldr (+) 0 (1:2:3:[])
          == 1 +           foldr (+) 0 (2:3:[])
          == 1 + (2 +      foldr (+) 0 (3:[])
          == 1 + (2 + (3 + foldr (+) 0 []))
          == 1 + (2 + (3 + 0))

引用

foldl顾名思义从左边,向右卷起来. step zero x
foldr顾名思义从右边,向左卷起来. step x zero
zero位置和方向一致.

In fact, we can even write foldl using foldr!

----------4.6章节

  :type dropWhile
dropWhile :: (a -> Bool) -> [a] -> [a]

                  haskell的function都是单参数.类型标注是右结合.所以如下:

a -> Bool) -> [a] -> [a] = ((a -> Bool) -> ([a] -> [a]))
意思是:接收一个函数(a -> Bool) ,返回一个函数 [a] -> [a]

xs@(_:xs') = "hello"   --------- xs等于hello,xs'等于ello

like erlang (X=[_|T])="hello"

评论

3 楼 dogstar 2010-05-01  

forsecond 写道

汗 盗用俺的头像

s.h.i.t,这个是gtalk里的标准头像好不.囧...

2 楼 forsecond 2010-04-30  

汗 盗用俺的头像

1 楼 coolspeed 2009-06-23  

堆叠起来的[传递函数]透明度低于堆叠的对象。很多现在OOP擅长的领域，FP表达困难，应非偶然。
状态同步，目前是最直接的方式，但本身的不自然显而易见，越用越麻烦也是正常了。透明度增加了，人的可控性才能增加，因此我们高兴，但又同时因为透明度增加，复杂度也增加了，因此我们又沮丧。
现实世界里，作用被传递时，传的到底是什么呢？