fleurer » FP

State Monad笔记二

fleurer — Fri, 05 Mar 2010 10:25:08 +0000

老师：Monad想到什么呢？
同学：毛茸茸的猫猫!

好同学们，请默念“Warm and Fuzzy”100遍~

。。
。。
。。
。
。
。
。
。
。

。
。
。
。。
。。

100遍了没。。。好，我们先看看State猫猫的类型吧 ^_^

newtype State s a = State { runState :: s -> (a, s) }

里面有个难看的record syntax，咱们无视之，改成：

data State g v = State (g -> (v, g))

就是一个lambda，外加一二元组：v表示猫猫正经计算中的值，g就表示猫猫的状态啦(就一个全局变量嘛)~那个lambda的参数g也一样。相应的猫猫Instance也就是如下：

instance Monad (State g) where
    return v = 
        State $ \g -> (v, g)
 
    (>>=) (State m) f = 
        State $ \g -> 
                let (v, g') = m g
                    (State m') = f v
                in  m' g'

还是一环套一环，函数编程没有变量，那就向下传递的时候改变它的值就行了。再加两个小喽骡：

get_g = State $ \g -> (g, g)
set_g v = State $ \_ -> (v, v)

全局变量的值不也在那个lambda的参数里么，get_g它设成计算中的值，这样在do-notation中就可以g <- get_g了。set_g则是把它的参数设到g里，而原先的g无视扔掉即可。

加个函数试验下：

run (State m) i = m i 
 
add1 :: State Int Int
add1 = do {
    g <- get_g;
    set_g $ g + 1;
}
 
add3 = do {
    add1;
    add1;
    add1;
}

进ghci输入run add3 1可得(4,4)，可见那个“全局变量”就这么变化了。

回头再想想它的类型，一个二元组不就够了嘛，为什么要套那层lambda呢？试下就知道

data State g v = State (g, v) 
 
instance Monad (State g) where
    (>>=) (State (g, v)) f = (g, f v)

看着不错，接着来：

    return v = ...

发现问题了没，return我们实现不了…搞不到原先g的值，链子就断在了这一环。解决方法就是把它推后，不是没有g么，于是放到参数里等着别人(>>=)给，这算不算惰性呢？ :)

ps:明白了State是怎么回事，附一山寨parsec ^_^ http://github.com/Fleurer/FParser

State Monad笔记一

fleurer — Thu, 25 Feb 2010 12:19:40 +0000

去年听王猫猫讲过之后就一直心安理得再也没看过Monad，以至于到昨天还不知State Monad为何物…囧

关于State Monad，似乎见过的教材都是拿随机数作例子，拿Monad跟一堆let对比，满眼的二元组绕啊绕啊，我给你个Monad让它不那么绕（存疑）～其实什么东西理解不了，往往就是因为不知道它怎么用（比如复变函数 =”=）

换个例子，像那个筛掉一个List中重复元素的nub函数多好….在命令式语言下边大约是这样：

def nub(xs)
    result=[]
    for x in xs
        if not result.include? x
	     result << x
    return result

若在函数式语言下边，用迭代大约是这样：

inub :: (Eq a) => [a] -> [a]
inub = inub' [] 
inub' rs [] = rs
inub' rs (x:xs) 
    | x `elem` rs    = inub' rs xs
    | otherwise     = inub' (rs++[x]) xs

inub’这个函数中有个rs参数，就相当于前面那个result变量。它的值会随着迭代发生改变，不同之处就是ts是引用透明的没有副作用。每次函数调用就是一个状态，状态就是一个值。

不喜欢给函数多加个参数怎么办？State Monad可以做到。在State Monad里面有两个函数可以使用：put，设置当前状态的值；get，获得当前状态的值。就相当于给函数加了一个（只有一个）可变的全局变量，在调用别的函数或者递归时这个值可以保留。

State Monad版本（我没觉得好看 =”=）：

mnub :: (Eq a) => [a] -> [a]
mnub xs = evalState (mnub' xs) []
mnub' [] = get
mnub' (x:xs) = do {
    rs <- get;
    if x `elem` rs then (do {
        mnub' xs;
    })
    else (do {
        put $ (rs++[x]);
        mnub' xs;
    });
}

原理大约就是do-notation中的每个语句都是用一个wrapper的类型包起来再不断往下传递么，而State的wrapper就是个类型为(a,s)的二元组（外加一层lambda？），每个语句的返回值放到s里，那个全局的值则放在a里…具体还有点迷糊，哪天推导下再说好了 >_<

Haskell趣学指南！

ssword — Fri, 11 Dec 2009 17:22:02 +0000

译言前几天被杯具了，还好当初嗅到苗头全都抓了来 -v-

新地址见http://fleurer-lee.com/lyah。

用自己写的小工具生成的html，parser的代码不到200行，代码写的非常之perl，不过显然还算够用。
代码高亮用的一个jquery插件Chili，很容易扩展，随便改两个正则就自制了个haskell高亮。

顺便校对了下翻译。

ChinaUnix上的朋友对“柯里函数”等译法的意见比较大，不过在校对中没有做修改。关于人名构成的术语，例如“Fourier transform”还是“傅立叶变换”，译者认为后者更好看。
“Function Application”直译作“函数应用”，在这里译为“函数调用”。相应的“partial application”直译作“部分应用”，在这里译为“不全调用”。
“predicate”在这里译为“限制条件”，因为译者认为“断言”这个词有点吓人。
保留了List，Tuple，List Comprehension等名词，不过将Triple之类译为“三元组”，“function with two parameters”译为“二元函数”。
把原先译文中“在处理数字时是非常有用的”类的句式改为“在处理数字时非常有用”，“的”真的是很别扭的。
有一节的标题“Texas Range”译为“德州区间”，因为译者老家在德州…囧

修改的比较仓促，bug依然还有很多。呵呵，欢迎提意见！ ^_^

update: 可以svn checkout它的源码：https://lyah-cn.googlecode.com/svn/trunk/

理解Y组合子

ssword — Sat, 19 Sep 2009 06:00:55 +0000

众所周知，lambda演算通过递归就可以图灵完备。好，用纯lambda演算写个递归吧。

等等，要递归必须得有名字，而lambda演算里赋予名字的唯一方式就是传递参数。像lisp那样define可不行啊。只能这样绕个圈子：

(\f.\x.
    (if  (= x 1)
        1
        (* x (f f  (- x 1)))))

这里把函数本身作为第一个参数传递给自己，从而实现的递归。要调用这个递归函数，还得套一个let（当然，换成lambda形式）:

((\fac. (fac fac 5))
        (\f.\x.
              (if (= x 1)
                    1
                    (* x (f f (- x 1))))))

真难看！每次递归都得把自己当作参数传递一遍，很机械！机械的活不应由人类做！想下，如果将递归函数里的(f f (- x 1))换成(f (- x 1))，或许还可以接受…好，Y组合子应运而生，现在你可以这样自然地递归了：

Y (\f.\x
     (if (= x 1)
          1
          (* x (f (- x 1))))) 5

数学家在追求美感上可是不遗余力啊。不过Y是如何做到的？

想想，Y组合子又叫不动点函数。什么是不动点？x=f(x)=f(f(x))…，这个x就是不动点：不管套多少层函数调用，在不动点上的值总是相等。Y f = f (Y f)=f (f (Y f))，这个Y f就是个不动点，高阶函数的不动点。什么是组合子？很简单，可以柯里化、没有自由变量的函数就是组合子 :)

便于理解，我们给(\f.\x (if (= x 1) 1 (* x (f (- x 1)))))这个lambda一个名字fac，看看一步步的递归是怎么来的：

Y fac 3
> fac (Y fac) 3         	//transform, Y!
> 3 * ((Y fac) 2)        	//3 !=1 so recurse
> 3 * (fac (Y fac) 2)    	//Y transform again
> 3 * (2 * ((Y fac) 1))       //2 !=1 so recurse
> 3 * (2 * (fac (Y fac) 1))   	//Y transform again
> 3 * (2 * 1)             	//1=1, so recursion ends.
> 6

就是这样了。里面有柯里化，也有惰性求值（缺一不可！）。一环套一环，然后就递归了。

Y组合子的定义：Y = \y. (\x.y (x x)) (\x.y (x x))，天知道大神（大神的名字叫做Haskell Curry! -v-）是怎么想出来的 =v=

不妨自己在纸上推倒一下(也只能在纸上推倒，这东西在实际的编程中貌似是没有应用的 :D)

杯具渔民交流群 -_-!

ssword — Sun, 13 Sep 2009 02:28:34 +0000

58853867

原haskell交流群

并行的quicksort

ssword — Fri, 24 Jul 2009 13:01:21 +0000

haskell搞并行还是挺方便的。纯函数式没状态嘛，这儿锁啊钥匙啊什么的都不用管了。有个Control.Parallel，里貌似只有两个函数，一个par，表示两个并行计算；一个pseq，表示连续计算。参数都是两个名字。像处理个分治算法啥的，就再合适不过了。于是再次膜拜惰性求值，写起来真的太奇特了。

module Main where
import Control.Parallel
 
--the classic one
qsort :: (Ord a) => [a] -> [a]
qsort [] = []
qsort (x:xs) =
 (qsort lt) ++ [x] ++ (qsort gt)
 where
  lt = filter (<x) xs
  gt = filter (>=x) xs
 
 
--the parallel one
psort :: (Ord a) => [a] -> [a]
psort [] = []
psort (x:xs) =
 sorted_lt `par` sorted_gt `pseq` (sorted_lt ++ [x] ++ sorted_gt) ----unbelieveable,isn't it? :>
 where
  sorted_lt = psort $ filter (<) xs
  sorted_gt = psort $ filter (>=x) xs
 
 
main = do {
 list <- return [5000,4999..1];
 print $ qsort list;
 print $ psort list;
}

profile下，给ghc添加一个编译选项 -prof -O：

ghc --make -prof -O -auto-all quicksort.hs

执行程序，加一个选项 +RTS -p，它会在本目录下生成一个quicksort.prof文件

quicksort +RTS -p

quicksort.prof文件的部分内容：

 Mon Jul 20 16:40 2009 Time and Allocation Profiling Report  (Final)

    quicksort +RTS -p -RTS

 total time  =        6.86 secs   (343 ticks @ 20 ms)
 total alloc = 1,401,627,416 bytes  (excludes profiling overheads)

COST CENTRE                    MODULE               %time %alloc

qsort                          Main                  69.1   49.9
psort                          Main                  30.9   49.9

可见在这台双核的机器上，性能提高了一半多 :)
ps:测试的数据貌似不是很好（按说该用个随机数列），不过知道有这回事就行了~

王猫猫谈Monad

ssword — Mon, 20 Jul 2009 03:18:15 +0000

Feather 2009-07-19 21:46:08

世事恰如迷局, 寻人, 失散, 流落, 皈依, 纷乱无绪, 及至谜底解开, 那人却已站立在你面前.

Feather 2009-07-19 21:46:46

Feather 2009-07-19 21:46:50

继续讲么

Feather 2009-07-19 21:47:02

没了?

Fleurer 2009-07-19 21:47:08

别的不知道了…

Feather 2009-07-19 21:47:15

不要啊

Fleurer 2009-07-19 21:47:25

Feather 2009-07-19 21:47:24

我关于Monad 有一本笔记

Feather 2009-07-19 21:47:31

扔学校了

Fleurer 2009-07-19 21:47:40

拉门

Feather 2009-07-19 21:47:43

哈哈

Fleurer 2009-07-19 21:47:57

讲讲讲讲

Feather 2009-07-19 21:48:11

从哪开始

Feather 2009-07-19 21:48:16

你有离散数学基础没?

Fleurer 2009-07-19 21:48:28

貌似看过一点

Feather 2009-07-19 21:49:20

哦

Feather 2009-07-19 21:49:21

那就好

Feather 2009-07-19 21:49:25

开始讲昂

Fleurer 2009-07-19 21:49:34

Feather 2009-07-19 21:49:48

first

Feather 2009-07-19 21:50:00

let talk about some basic concepts

Fleurer 2009-07-19 21:50:10

Feather 2009-07-19 21:50:16

what is type?

Fleurer 2009-07-19 21:50:21

Feather 2009-07-19 21:50:35

tell me what you think about type

Feather 2009-07-19 21:50:38

“type”

Feather 2009-07-19 21:50:41

what is it

Fleurer 2009-07-19 21:50:55

emm…

Fleurer 2009-07-19 21:51:02

a system?

Fleurer 2009-07-19 21:51:59

hold value…operation…and so … make program easier to be understood by machine?

Feather 2009-07-19 21:52:28

ok~

Fleurer 2009-07-19 21:52:35

Feather 2009-07-19 21:53:13

you just give us the ‘Class/Instance” definition in haskell

Fleurer 2009-07-19 21:53:41

what’s more…

Feather 2009-07-19 21:53:48

no no no

Feather 2009-07-19 21:53:56

there’s no “what’s more’

Feather 2009-07-19 21:54:02

but what’s less.

Feather 2009-07-19 21:54:10

for short, a type is just a set

Feather 2009-07-19 21:54:12

set~

Feather 2009-07-19 21:54:14

just set

Feather 2009-07-19 21:54:16

no more

Fleurer 2009-07-19 21:54:19

set~

Feather 2009-07-19 21:54:25

understand?

Fleurer 2009-07-19 21:54:28

set of integer

Fleurer 2009-07-19 21:54:31

set of string

Feather 2009-07-19 21:54:32

ya~

Feather 2009-07-19 21:54:35

set of Monad

Feather 2009-07-19 21:54:38

haha ~

Feather 2009-07-19 21:55:01

understand?

Fleurer 2009-07-19 21:55:35

maybe mis the point , but Monad is a set of types?

Feather 2009-07-19 21:56:01

forget my saying “set of Monad” first

Fleurer 2009-07-19 21:56:16

ramen

Feather 2009-07-19 21:56:33

Fleurer 2009-07-19 21:56:39

plz go on :>

Feather 2009-07-19 21:56:46

what is function?

Fleurer 2009-07-19 21:56:58

emmm

Fleurer 2009-07-19 21:57:08

a map between sets?

Fleurer 2009-07-19 21:57:13

D -> R

Fleurer 2009-07-19 21:57:25

Int -> String

Fleurer 2009-07-19 21:57:42

Feather 2009-07-19 21:57:43

a set of combination (a,b)~

Feather 2009-07-19 21:57:45

yes?

Feather 2009-07-19 21:58:02

let’s take a simple e.g.

Fleurer 2009-07-19 21:58:07

Relation?

Feather 2009-07-19 21:58:08

the function `inc`

Feather 2009-07-19 21:58:45

for clear definithion of `function`, refer to some book

Fleurer 2009-07-19 21:58:46

Feather 2009-07-19 21:59:06

inc = { …, (0,1), (1,2), (2,3)…..}

Feather 2009-07-19 21:59:09

yes?

Feather 2009-07-19 21:59:16

so we give `inc 2`

Feather 2009-07-19 21:59:20

we got 3

Fleurer 2009-07-19 21:59:33

Feather 2009-07-19 21:59:55

lalala ~~~~

Fleurer 2009-07-19 22:00:12

so?

Feather 2009-07-19 22:00:29

so~ a monoid~

Feather 2009-07-19 22:00:35

what is monoid

Fleurer 2009-07-19 22:00:45

monoid

Feather 2009-07-19 22:00:45

a set, whith some operation

Fleurer 2009-07-19 22:01:18

then what’s the difference between a monoid & a function?

Fleurer 2009-07-19 22:01:37

and difference between a monoid & dict?

Feather 2009-07-19 22:01:43

~~~~~~~~

Feather 2009-07-19 22:01:45

wrong

Fleurer 2009-07-19 22:01:54

Feather 2009-07-19 22:01:55

consider this

Fleurer 2009-07-19 22:02:08

Feather 2009-07-19 22:02:48

a monoid is a set M, together with an operation “●” that combines any two elements a and b to form another element denoted a ● b.

Feather 2009-07-19 22:02:57

formal definition here

Feather 2009-07-19 22:03:14

● is called product

Fleurer 2009-07-19 22:03:28

multiply?

Fleurer 2009-07-19 22:05:09

orz ,forget my last word

Feather 2009-07-19 22:05:17

sorry

Fleurer 2009-07-19 22:05:18

plz go on :>

Feather 2009-07-19 22:05:47

the pc got slow…

Fleurer 2009-07-19 22:05:53

ya?

Feather 2009-07-19 22:05:56

because i am compiling…

Fleurer 2009-07-19 22:06:21

compiling is ram hungry…

Feather 2009-07-19 22:06:28

for e.g

Feather 2009-07-19 22:06:34

int, *

Feather 2009-07-19 22:06:41

in the set int

Feather 2009-07-19 22:06:48

we define *

Fleurer 2009-07-19 22:07:02

Feather 2009-07-19 22:07:24

here we can see what the monoid is

Feather 2009-07-19 22:07:47

3 important axioms

Fleurer 2009-07-19 22:07:49

oui?

Feather 2009-07-19 22:07:51

Feather 2009-07-19 22:07:54

closure

Feather 2009-07-19 22:08:05

int * int is a int , not other thing

Feather 2009-07-19 22:08:13

2> Associatiity

Feather 2009-07-19 22:09:09

for int a,b,c

Feather 2009-07-19 22:09:23

(a*b)*c equals to a*(b*c)

Feather 2009-07-19 22:09:26

see?

Fleurer 2009-07-19 22:09:33

got it

Fleurer 2009-07-19 22:10:21

3rd?

Feather 2009-07-19 22:10:21

Feather 2009-07-19 22:11:05

the e, so called `one`

Feather 2009-07-19 22:11:21

for any int a
e * a = a * e = a

Feather 2009-07-19 22:11:34

note, my e.g. is not very good

Feather 2009-07-19 22:12:14

so e here is the identity element

Fleurer 2009-07-19 22:12:35

like 1 in Int?

Feather 2009-07-19 22:13:09

yes

Fleurer 2009-07-19 22:13:33

linear?

Feather 2009-07-19 22:14:22

[Int] is a Monoid

Feather 2009-07-19 22:14:44

the product is ++

Feather 2009-07-19 22:14:51

the id is?

Feather 2009-07-19 22:14:54

tell me

Fleurer 2009-07-19 22:15:05

[]?

Feather 2009-07-19 22:15:18

yes~

Feather 2009-07-19 22:15:33

so what is Functor

Fleurer 2009-07-19 22:15:41

Feather 2009-07-19 22:16:18

…er…

Feather 2009-07-19 22:16:26

not this fast

Fleurer 2009-07-19 22:16:42

oui

Feather 2009-07-19 22:17:00

first let’s talk about category

Fleurer 2009-07-19 22:17:52

Feather 2009-07-19 22:18:17

what is category

Fleurer 2009-07-19 22:18:23

？

Feather 2009-07-19 22:18:28

so many whats… :)

Fleurer 2009-07-19 22:19:01

heihiehie

Feather 2009-07-19 22:19:42

now you know what monoid is

Feather 2009-07-19 22:19:57

let’s consider category

Fleurer 2009-07-19 22:21:16

yeah

Feather 2009-07-19 22:21:27

so slow a computer is ….

Fleurer 2009-07-19 22:21:43

compiling eats computer…

Feather 2009-07-19 22:22:36

a category…

Feather 2009-07-19 22:22:57

Feather 2009-07-19 22:23:22

objects + arrows

Fleurer 2009-07-19 22:23:25

？

Feather 2009-07-19 22:23:53

what is arrow here?

Fleurer 2009-07-19 22:24:10

-> ?

Feather 2009-07-19 22:24:17

fuck

Feather 2009-07-19 22:24:22

no haskell code here

Fleurer 2009-07-19 22:24:42

so … just an arrow?

Feather 2009-07-19 22:24:59

haha ~ good

Feather 2009-07-19 22:25:06

it is ———————->

Fleurer 2009-07-19 22:25:17

——————————————————————->

Feather 2009-07-19 22:25:30

arrow is just an arrow from an object to an object

Fleurer 2009-07-19 22:25:40

map?

Feather 2009-07-19 22:25:43

consider this,

Fleurer 2009-07-19 22:25:55

Feather 2009-07-19 22:26:32

objects = 1,2,3,4,5,6….

Fleurer 2009-07-19 22:26:50

an infinite set?

Feather 2009-07-19 22:27:10

arrow = 1->2, 3->3, 4->5, 5->6

Feather 2009-07-19 22:27:20

call it whatever you like ~

Feather 2009-07-19 22:27:31

they are objects

Feather 2009-07-19 22:27:43

and wo got arrows 1->2, 3->3, 4->5, 5->6 …

Fleurer 2009-07-19 22:27:50

er…. so …. map among themselves?

Feather 2009-07-19 22:28:02

understand what object and arrow is?

Feather 2009-07-19 22:28:25

here we define an action~

Feather 2009-07-19 22:28:28

coposite

Fleurer 2009-07-19 22:28:30

yea…. maybe

Feather 2009-07-19 22:28:43

composite, fuck , spell ….

Feather 2009-07-19 22:29:23

objects = 1,2,3,4,5,6….
arrows 1->2, 3->3, 4->5, 5->6 …

Fleurer 2009-07-19 22:29:37

so ?

Feather 2009-07-19 22:30:24

(1-2)◎(2->3) we got 1->3

Feather 2009-07-19 22:30:28

haha ~ see?

Feather 2009-07-19 22:30:34

this is composite

Fleurer 2009-07-19 22:31:28

like . in haskell?

Feather 2009-07-19 22:31:43

fuck, i said no more haskell code

Fleurer 2009-07-19 22:31:52

ramen

Feather 2009-07-19 22:31:57

it is composite in category

Feather 2009-07-19 22:31:58

here

Fleurer 2009-07-19 22:32:09

so … composite makes a link?

Feather 2009-07-19 22:32:13

(1-2)◎(2->3) ~ this is composite

Fleurer 2009-07-19 22:33:17

Feather 2009-07-19 22:34:28

((1-2)◎(2->3))◎(3->4)

Feather 2009-07-19 22:34:35

what is it?

Fleurer 2009-07-19 22:34:47

two composites?

Feather 2009-07-19 22:35:03

and compare with

Feather 2009-07-19 22:35:04

(1-2)◎( (2->3)◎(3->4) )

Fleurer 2009-07-19 22:35:27

they equal?

Feather 2009-07-19 22:35:31

yes

Feather 2009-07-19 22:35:39

so recall what monoid is

Fleurer 2009-07-19 22:35:43

assoc

Feather 2009-07-19 22:35:49

this is called~ associativity

Feather 2009-07-19 22:35:50

yes

Feather 2009-07-19 22:35:53

clever

Feather 2009-07-19 22:35:55

Feather 2009-07-19 22:35:59

haha

Fleurer 2009-07-19 22:36:01

orz, i can’t recall the word..窘

Feather 2009-07-19 22:36:26

we have assoc… here

Feather 2009-07-19 22:37:22

and for every object

Feather 2009-07-19 22:37:27

we define

Fleurer 2009-07-19 22:37:34

ye？

Feather 2009-07-19 22:37:36

for every object a

Feather 2009-07-19 22:37:44

we define Ia

Fleurer 2009-07-19 22:38:06

to identify itself?

Feather 2009-07-19 22:38:37

I3 ◎ (3->2) ====== (3->2)◎I3 ======= (3->2)

Feather 2009-07-19 22:39:06

we also have I1, I2, I3, Ix…..

Fleurer 2009-07-19 22:39:11

a start point ?

Feather 2009-07-19 22:39:23

this is called identity

Feather 2009-07-19 22:39:30

identity in ◎

Feather 2009-07-19 22:40:22

I3 ◎ (3->2) ====== (3->2)◎I2 ======= (3->2)

Fleurer 2009-07-19 22:40:28

oh ,got it . like I3, identify this object is 3?

Feather 2009-07-19 22:40:50

I3 * (3 -> x) ====== =3->x

Feather 2009-07-19 22:41:01

here we use ints as objects

Fleurer 2009-07-19 22:41:23

yeah?

Feather 2009-07-19 22:41:41

use `identity arrow`

Feather 2009-07-19 22:41:54

composite another arrow

Feather 2009-07-19 22:41:59

what we got?

Fleurer 2009-07-19 22:42:08

a link?

Feather 2009-07-19 22:42:09

the arrow unchanged

Feather 2009-07-19 22:42:11

fuck

Feather 2009-07-19 22:42:35

we talk about arrow

Fleurer 2009-07-19 22:42:42

窘

Feather 2009-07-19 22:42:43

why you always link, link, link

Feather 2009-07-19 22:42:50

what do you want to link?

Feather 2009-07-19 22:42:54

spring brother?

Feather 2009-07-19 22:43:10

Fleurer 2009-07-19 22:43:13

ramen, i’ve made a mistake

Feather 2009-07-19 22:43:20

let’s go on

Feather 2009-07-19 22:43:23

Fineday

ssword — Sun, 14 Jun 2009 06:15:45 +0000

学习haskell一段时间了，关于monad等等东西仍停留在理论上的理解而不了解其应用，练下手总是好的。于是参考这个有名的《Write Yourself a Scheme in 48 Hours》和parsec的手册，实现了个简单的语言。只是简单的递归解析语法树，也没有中间编译，也没有垃圾收集，实现起来还是比较简单的。某天天气不错，晴天，就叫它Fineday。

Fineday的语法比较接近javascript（其实一开始是打算搞成basic-style的，可是不会写bnf…囧），有基本的控制流程if，while,for，有匿名函数，有闭包，有数组，有hash—当然，是忽略了许许多多细节的实现，例如没有求数组length的函数，只有puts而没有gets，没有Int类型（开始的时候为了方便一切都是double），没有像样子的错误提示…呵，but it runs.

像下面这段可以算是一个猥琐的oo实现了:

function makeCounter(init){
    var this={
        'n':init,
        'add':function(n){
            this['n']=this['n']+n;
            return this['n'];
        }
    };
    return this;
}
var counter=makeCounter(1);
puts((counter['add'])(2)); --3
puts(counter['add'](3));   --6

前几天又翻了下姐姐送的那本《the ruby way》的序，matz谈及ruby语言的设计时提到了“道”，以及编写ruby时的信条：语言应该为人类服务，而不是相反。于是认识到，语言的设计绝非信手拈来的活计，设计中有太多需要斟酌的地方，有太多需要用心思考的地方。我等玩代码的，还是差的太远了。

项目地址：http://code.google.com/p/fineday/
呵，空白的，懒得再写字了。可以用svn获得源代码及编译的exe文件。

Haskell：可变状态的命令式语言

ssword — Sat, 13 Jun 2009 06:16:46 +0000

作者：Neil
翻译：ssword
原文：http://neilbartlett.name/blog/2007/04/11/haskell-an-imperative-language-with-mutable-state/

Haskell是一门惰性的纯函数式语言，也就意味着其中没有可变的变量。呃，有，没有？看下这个Factorial的haskell实现吧：

fact n = runST (do
    r < - newSTRef 1
    for (1,n) (\x -> do
       val < - readSTRef r
       writeSTRef r (val * x))
    readSTRef r)

嗯，我可没说这样写好。实际上，这样写很糟糕，一行纯函数式代码就可以漂亮的搞定同样的工作。不过请注意下这代码与命令式语言是如何的相像，如对“可变变量”r的破坏性更新。再贴一下，与同等的C代码做个对比：

 
fact n = runST (do               | int fact(int n) {
     r < - newSTRef 1             |    int r = 1;
                                 |    int i;
     for (1,n) (\x -> do         |    for(i=1;i< =n;i++) {
         val <- readSTRef r      |
         writeSTRef r (val * x)) |       r = r * i;
                                 |    }
     readSTRef r)                |    return r;
                                 | }

瞧，你几乎可以把C的代码一对一地翻译成haskell。不过得承认，haskell的语法要猥琐些。

这一切是如何做到的呢？答案就是ST monad，有了它就可以写出有内部状态更新而对外仍保持纯粹的算法。runST函数是亮点，它创建了个初始的空状态，然后执行一系列的状态转换，到最后再销毁它。fact依然是Int->Int的纯函数，依然保留了引用透明。

另一个亮点是那个“for”，看起来跟个关键字一般，不过它本质就是一普通函数，定义如下：

for :: (Int,Int) -> (Int -> ST s ()) -> ST s ()
for (i,j) k = sequence_ (map k [i..j])

同理，我们也可以定义出foreach，if，while等等。有haskell这般强大的表达力，没必要再将控制流的操作定义为语言的关键字；我们甚至可以根据自己的需求来发明新的控制流程。

不过你看出来了没？没人会正二八经地像上面那样实现factorial。而且，我们真的希望如这般曲解haskell，以取悦从C过来的老程序员么？

是的，问题就在这里。有这项技巧，是为那些已知难以使用函数式风格或递归搞定的算法提供的折衷。同样，很多算法需要用到数组—–有限的内存和固定的访问时间—–使其更易于处理。在ST monad中实现数组很容易，但在传统的纯函数式代码中就要困难多了。（UPDATE：Cale说，纯代码中实现不可变的数组还是很容易的，只有可变的数组实现其来才困难）。

恩，ST monad和STRef表示了外部不可见的局部状态，那么全局的可变状态呢？我们可以用IO monad和IORef做到。当然，在用IO的时候就没有像runST那样回到纯代码的函数了[1]。

对我，这引发的思考就是：haskell是真正的纯函数式语言吗？我觉得不是—–它超越了纯函数式。它是既允许命令式编程，又使用强大类型系统来把有副作用的代码与纯代码分离。这一点，令它强大无比。

[1] 这不是绝对…其实有个方法：unsafePerformIO。不过我觉得应该辩证地讨论它。

理解continuation

ssword — Sat, 06 Jun 2009 05:34:20 +0000

当时小，不懂事，初学函数式编程时一头就扎的就是continuation和monad，一直搞不明白就一直放着。上个星期在ShiningRay老师的这篇《简介延续“Continuation”》里看到：

def call_cc(f,c):
     f(c,c)

貌似很泪流满面的样子，没想到这东西有这么简单。之后在图书馆里写了一个小时的伪代码，貌似搞明白了。按照Continuation Passing Style(cps)的设定，函数没有返回值，而是用函数的运算结果调用函数最后一个参数，很简单吧。不过那些特性又是从何而来呢，像保存状态尾递归优化之类？现在想想，之前之所以不理解，大概就是因为不会写cps的递归吧，其实动手写的话也就那回事。国父孙先生不是说么，知难行易。

如下伪代码，求前n个自然数的和：

def sum(n):
    if (n==0): 0
    else :
        n+sum(n-1)

换成等价的前缀形式(if就懒得改了，知道这回事就好)：

def sum(n):
	if (n==0): return 0
    else
        return add(n, sum(sub(n,1)))

好，换成cps：

def sum(n,c):
    if (n==0): c(0) #“延续”下去，而不是返回
    else:
        sub n, 1, (\x1 -> #一个lambda，匿名函数
        sum x1, (\x2 -> #递归在这里
        add x2 ,n ,c))

再一个迭代的例子：

def iter_sum(n, r):
     if (n==0) : return r
     else : iter_sum(n-1, r+n)

换成前缀：

def iter_sum(n,r):
     if (n==0): return r
     else : iter_sum(sub(n, 1), add(r,n))

cps:

def c_iter_sum(n,r,c):
    if (n==0): c(r)
    else:
        sub n, 1, (\x1 ->
        add r, n, (\x2 ->
        c_iter_sum(x1, x2, c))) #尾递归

可以看出，cps中引入了些自由变量，把函数求值的结果放在堆里而非栈中，于是就可以实现不限深度的递归。不过这样貌似增加了垃圾收集的负担，没有银弹哇。

contiuation中只有“延续”而没有“返回”，每一步“延续”都是对后面函数的调用，通过一条函数与函数的链构成了顺序结构。ShiningRay老师貌似说过，一个函数调用就是一个状态。callcc貌似就是把“延续”的下一个函数保存，从而保存了状态。Smalltalk的那个Seaside框架貌似就是把contiuation作为对象持久化，在下次访问时找到这个持久化的contiuation将状态还原，从而模拟出仿桌面程序开发的效果。貌似要比asp.net那WebForm的实现更加自然些。