急,急！！再次跪求:会计master申请,大多数学校是TOFEL和GMAT都要吗?（有绿卡） - 未名空间MITBBS历史存档

国际科技财经博客移民网络热点娱乐民生时事公众号

Redian新闻

>未名空间

>Accounting - 会计审计

急,急！！再次跪求:会计master申请,大多数学校是TOFEL和GMAT都要吗?（有绿卡）

急,急！！再次跪求:会计master申请,大多数学校是TOFEL和GMAT都要吗?（有绿卡）# Accounting - 会计审计

s*n2013-01-12 08:01

1 楼

全新未开封。买回来以后发现家里太小放不下，现在转让。有兴趣的站内联系。
MK50 Keyboard Amplifier
http://www.musiciansfriend.com/keyboards-midi/phonic-mk50-keybo

v*k2013-01-12 08:01

2 楼

月关也没点自知之明。写点soft porn就行了，非要学人家称霸天下

p*22013-01-12 08:01

3 楼

http://www.efytimes.com/e1/fullnews.asp?edid=125719
八种最值得学习的语言
Haskell, Erlang, Clojure, OCaml都在列。Scala很不给力呀。

y*a2013-01-12 08:01

4 楼

前面发过了，但没人理，可能是因为太长了，精简一下，求大家帮帮忙吧，感谢了。
本人国内一般211文科本科文凭，英语很好，有绿卡，现在社区大学学会计希望尽快申
请念会计硕士：
问一：大多数学校TOFEL和GMAT都要吗？还是只要GMAT? （虽然听说各校要求不一样，
但还是想知道大概，不想白费时间和金钱，有孩子，还要上班）自己在家该怎么准备
？哪里找资料？（TOFEL这玩艺儿，到底跟哪个有关？绿卡还是是否有美国本土的学位
？）
问二：在这里看了好多贴子提到学校排名，请问这种信息上哪里找啊？？求推荐三藩，
纽约或者西雅图的学校，要好找工作的，又能考CPA。
问三：申请奖学金的条件是什么？是不是跟本科成绩和GMAT分数很有关联？有绿卡会不
会有点帮助呢？（老公也在念硕士，虽然是全奖，但我的工作烂，还有小孩，窘迫得很
啦，想想就愁）如果自掏腰包大概多少钱？？
谢了！

t*o2013-01-12 08:01

5 楼

我bid一下
12.99

c*i2013-01-12 08:01

6 楼

确实，他应该写一些大宅子里面买卖东西争宠的事情，比如《步步》的开始一段。现在
折子渝乱跑很没有逻辑，唐艳艳、吴娃儿都成了符号了，一点鲜活的个性都没有。冬儿
的爱情更是死气沉沉，总之是重复《回明》的一套。

c*o2013-01-12 08:01

7 楼

你这个搞得像电视剧里痛恨ex的怨女一样。
BTW,
我现在在自学clojure,还是觉得scala 学FP 更好,我把 scala当haskell学。
不过clojure的设计很好，很独特，我最喜欢就是lisp的data <=> code 还有 super
powerful macro,
不过注定这两个特点 strong static type 语言不能有（会颠覆type check)。

y*a2013-01-12 08:01

8 楼

zijiding

e*o2013-01-12 08:01

9 楼

最近我也看了不少语言，我觉得 scala 和 lisp 是最值的学的。
关于haskell和scala 同意楼上，
Haskell 的难度在于怪异的syntax。
比如 Lists 的定义：
data [a] = [] | a : [a] deriving (Eq, Ord) 得半天才能看懂。
syntax 把 monad的学习的难度给增大了，或者说，syntax把monad 弄神秘了。
学 scala 的type，学起来也比较有意思。其它语言，基本用不到这些（我知道的）。

k*u2013-01-12 08:01

10 楼

我来答好了。
一，GMAT是肯定要的。至于TOFEL，如果你只有绿卡不是美本，大部分学校都是要求考
的。即使是美本，如果不是Native，有些TOP的学校也是要求你考的，列入UT-AUSTIN。
二，学校可以查PAR的排名，还有就是翻论坛旧贴。基本上会计这行找工作是要看学校
地址的。而且现在这个市场就这样了，大城市工作不少，可是要求也不低，好不好找工
作完全就是自己的事。不过你有绿卡，找纽约的会计工作应该没问题，西雅图的不知道
。有的也只是工资高低的问题。至于考CPA，那你自己得去查学校的课程安排跟你所要
考的州的要求，或者你直接打电话问学校。
三，大部分商科都是没有奖学金的，所以条件什么的我也不清楚。不过猜测应该是根据
你的面试表现跟简历来给的？并不觉得绿卡会有多大的帮助。另外学费要看你选的学校
跟要上的学分来决定啊。USC跟CUNY BARUCH的学费可不是只差一点点的。
希望有所帮助~GOOD LUCK！

n*12013-01-12 08:01

11 楼

其他语言里面的list大多都是language primitive,因为list本来就很难用一个library
来定义。 haskell能把list分离到语言之外已经很不错了。
如果要你在scala/java/python/c++里面实现自己的list，而且不准用array,你准备怎
么定义？
C++还好，有template和指针， C的实现基本只能用linked list+opaque pointer.
struct List {
void* payload;
List* next;
};
这个和haskell是等价的，都用到了循环定义。
其他几个我真不知道, 你写个java/scala的看看？

【在 e*******o 的大作中提到】

: 最近我也看了不少语言，我觉得 scala 和 lisp 是最值的学的。
: 关于haskell和scala 同意楼上，
: Haskell 的难度在于怪异的syntax。
: 比如 Lists 的定义：
: data [a] = [] | a : [a] deriving (Eq, Ord) 得半天才能看懂。
: syntax 把 monad的学习的难度给增大了，或者说，syntax把monad 弄神秘了。
: 学 scala 的type，学起来也比较有意思。其它语言，基本用不到这些（我知道的）。

H*72013-01-12 08:01

12 楼

LZ, 我也是正在往财会这个方向发展，看了你的帖子，来回应一下，希望能够帮到
你。
1, LZ, 如果你现在要申请master, 托福， GRE, 是一定要考的。托福，是测试
你的英语水平，当然，如果本科是在英语国家拿的，就不用考了。 GRE, 是测课
目综合知识，美本也是要考这个的。
2, 看看你LG去的学校，或附近学校，看看有没有会计这个专业和当地排名，去
咨询。
3，商课，是个读出来，就可以赚钱的工作，一般没有奖学金，（我身边很多朋
友，都是自费）。
祝你顺利，希望可以一起交流学习。

h*d2013-01-12 08:01

13 楼

这上面都是非主流语言，Scala 已经和C/C++/Java/Python/JS 等等成为主流了

【在 p*****2 的大作中提到】

: http://www.efytimes.com/e1/fullnews.asp?edid=125719
: 八种最值得学习的语言
: Haskell, Erlang, Clojure, OCaml都在列。Scala很不给力呀。

y*a2013-01-12 08:01

14 楼

感谢仁兄的回复，非常informative.很有用，谢谢了哈。

【在 k***u 的大作中提到】

: 我来答好了。
: 一，GMAT是肯定要的。至于TOFEL，如果你只有绿卡不是美本，大部分学校都是要求考
: 的。即使是美本，如果不是Native，有些TOP的学校也是要求你考的，列入UT-AUSTIN。
: 二，学校可以查PAR的排名，还有就是翻论坛旧贴。基本上会计这行找工作是要看学校
: 地址的。而且现在这个市场就这样了，大城市工作不少，可是要求也不低，好不好找工
: 作完全就是自己的事。不过你有绿卡，找纽约的会计工作应该没问题，西雅图的不知道
: 。有的也只是工资高低的问题。至于考CPA，那你自己得去查学校的课程安排跟你所要
: 考的州的要求，或者你直接打电话问学校。
: 三，大部分商科都是没有奖学金的，所以条件什么的我也不清楚。不过猜测应该是根据
: 你的面试表现跟简历来给的？并不觉得绿卡会有多大的帮助。另外学费要看你选的学校

c*o2013-01-12 08:01

15 楼

scala的list 就是library啊。。。
我自己还练习写了一个，包括所有的functor/applicative/monad界面。

library

【在 n****1 的大作中提到】

: 其他语言里面的list大多都是language primitive,因为list本来就很难用一个library
: 来定义。 haskell能把list分离到语言之外已经很不错了。
: 如果要你在scala/java/python/c++里面实现自己的list，而且不准用array,你准备怎
: 么定义？
: C++还好，有template和指针， C的实现基本只能用linked list+opaque pointer.
: struct List {
: void* payload;
: List* next;
: };
: 这个和haskell是等价的，都用到了循环定义。

y*a2013-01-12 08:01

16 楼

Angelic cat，感谢你的回复，看来只能自掏腰包卧薪尝胆一番了哈哈，谢谢。

【在 H***7 的大作中提到】

: LZ, 我也是正在往财会这个方向发展，看了你的帖子，来回应一下，希望能够帮到
: 你。
: 1, LZ, 如果你现在要申请master, 托福， GRE, 是一定要考的。托福，是测试
: 你的英语水平，当然，如果本科是在英语国家拿的，就不用考了。 GRE, 是测课
: 目综合知识，美本也是要考这个的。
: 2, 看看你LG去的学校，或附近学校，看看有没有会计这个专业和当地排名，去
: 咨询。
: 3，商课，是个读出来，就可以赚钱的工作，一般没有奖学金，（我身边很多朋
: 友，都是自费）。
: 祝你顺利，希望可以一起交流学习。

n*12013-01-12 08:01

17 楼

我的point是“data [a] = [] | a : [a] deriving (Eq, Ord)”简单明了超级易
懂，不过是用了循环定义。

【在 c******o 的大作中提到】

: scala的list 就是library啊。。。
: 我自己还练习写了一个，包括所有的functor/applicative/monad界面。
:
: library

V*32013-01-12 08:01

18 楼

美国这边好一点儿的会计MASTER都是要GMAT的，但有一些偏应用和给在职人员读的，有
的不要GMAT，比方说三蕃的GGU。如果楼主有绿卡，想省钱的话，可以先在社区大学读
几门课，然后TRANSFER到好学校，也许可以免一些学分，省一些钱。

n*12013-01-12 08:01

19 楼

我的point是“data [a] = [] | a : [a] deriving (Eq, Ord)”简单明了超级易
懂，不过是用了循环定义。

【在 c******o 的大作中提到】

: scala的list 就是library啊。。。
: 我自己还练习写了一个，包括所有的functor/applicative/monad界面。
:
: library

y*a2013-01-12 08:01

20 楼

谢谢你的回复，我正在社区大学，刚学到ACC102呢，这是不是只是皮毛，连TRANSFER的
资格都还不够啊？我正在考虑GGU，能说说吗？到底好不好？谢谢。

【在 V****3 的大作中提到】

: 美国这边好一点儿的会计MASTER都是要GMAT的，但有一些偏应用和给在职人员读的，有
: 的不要GMAT，比方说三蕃的GGU。如果楼主有绿卡，想省钱的话，可以先在社区大学读
: 几门课，然后TRANSFER到好学校，也许可以免一些学分，省一些钱。

c*o2013-01-12 08:01

21 楼

我写的和它类似，不过是没 implement eq/Ord
sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A] (head: A, tail: List[A]) extends List[A]
object List {
def apply[A](as: A*): List[A] =
if (as.isEmpty) Nil
else Cons(as.head, apply(as.tail: _*))
private def asString_internal[A](l: List[A]): String =
l match {
case Nil => ""
case Cons(head,tail) => head.toString + " " + asString_internal(tail)
}
def toString[A](l: List[A]): String =
"[ " + asString_internal(l) + "]"
/////////////
def sum(ints: List[Int]): Int = ints match { // A function that uses
pattern matching to add up a list of integers
case Nil => 0 // The sum of the empty list is 0.
case Cons(x,xs) => x + sum(xs) // The sum of a list starting with `x` is
`x` plus the sum of the rest of the list.
}

def product(ds: List[Double]): Double = ds match {
case Nil => 1.0
case Cons(0.0, _) => 0.0
case Cons(x,xs) => x * product(xs)
}
def append[A](a1: List[A], a2: List[A]): List[A] =
a1 match {
case Nil => a2
case Cons(h,t) => Cons(h, append(t, a2))
}
def foldRight[A,B](l: List[A], z: B)(f: (A, B) => B): B = // Utility
functions
l match {
case Nil => z
case Cons(x, xs) => f(x, foldRight(xs, z)(f))
}

def sum_new(l: List[Int]) =
foldRight(l, 0)((x,y) => x + y)

def product_new(l: List[Double]) =
foldRight(l, 1.0)(_ * _) // `_ * _` is more concise notation for `(x,y)
=> x * y`, see sidebar
def tail[A](l: List[A]): List[A] =
l match {
case Nil => sys.error("tail of empty list")
case Cons(_,t) => t
}
def setHead[A](l: List[A])(h: A): List[A] = l match {
case Nil => sys.error("setHead on empty list")
case Cons(_,t) => Cons(h,t)
}
def drop[A](l: List[A], n: Int): List[A] =
if (n <= 0) l
else l match {
case Nil => Nil
case Cons(_,t) => drop(t, n-1)
}
def dropWhile[A](l: List[A], f: A => Boolean): List[A] =
l match {
case Cons(h,t) if f(h) => dropWhile(t, f)
case _ => l
}
def init[A](l: List[A]): List[A] =
l match {
case Nil => sys.error("init of empty list")
case Cons(_,Nil) => Nil
case Cons(h,t) => Cons(h,init(t))
}
def length[A](l: List[A]): Int =
foldRight(l, 0)((_,acc) => acc + 1)
@annotation.tailrec
def foldLeft[A,B](l: List[A], z: B)(f: (B, A) => B): B = l match {
case Nil => z
case Cons(h,t) => foldLeft(t, f(z,h))(f)
}
def sum2(l: List[Int]) = foldLeft(l, 0)(_ + _)
def product2(l: List[Double]) = foldLeft(l, 1.0)(_ * _)
def reverse[A](l: List[A]): List[A] = foldLeft(l, List[A]())((acc,h) =>
Cons(h,acc))
def foldRightViaFoldLeft[A,B](l: List[A], z: B)(f: (A,B) => B): B =
foldLeft(reverse(l), z)((b,a) => f(a,b))
def concat[A](l: List[List[A]]): List[A] =
foldRight(l, Nil:List[A])(append)
def map_origin[A, B](la: List[A])(f: A => B): List[B] =
foldRight(la, Nil:List[B])((h,t) => Cons(f(h), t))
////
def unit[A](a: A): List[A] =
Cons(a, Nil)
def flatMap[A, B](la: List[A])(f: A => List[B]): List[B] =
concat(foldRight(la, Nil:List[List[B]])((h,t) => Cons(f(h),t)))
def join[A](lla: List[List[A]]): List[A] =
flatMap(lla)(la => la)
def compose[A,B,C](f: A => List[B], g: B => List[C]): A => List[C] =
a => flatMap(f(a))(g)
def apply[A,B](la: List[A])(f: List[A => B]): List[B] =
flatMap(f)(t1 => flatMap(la)(t2 => unit(t1(t2))))
def map2[A,B,C](la: List[A], lb: List[B])(f: (A, B) => C): List[C] =
apply(lb)(apply(la)(unit(f.curried)))
def map[A, B](la: List[A])(f: A => B): List[B] =
apply(la)(unit(f))
def fold[A](l: List[A])(z: A)(op: (A, A) ⇒ A): A =
foldRight(l, z)(op)
def filter[A](l: List[A])(f: A => Boolean): List[A] =
foldRight(l, Nil:List[A])((h,t) => if (f(h)) Cons(h,t) else t)
}

【在 n****1 的大作中提到】

: 我的point是“data [a] = [] | a : [a] deriving (Eq, Ord)”简单明了超级易
: 懂，不过是用了循环定义。

y*o2013-01-12 08:01

22 楼

学校每年都有很多GA的工作机会，第一学期学扎实点，然后可以在学校试着找TA,GA的
工作，这样就可以免去很多学费，同时也可以积攒些财务会计相关的工作经验。

【在 y*******a 的大作中提到】

: Angelic cat，感谢你的回复，看来只能自掏腰包卧薪尝胆一番了哈哈，谢谢。

p*o2013-01-12 08:01

23 楼

用类就行了。java和python都类似。
class Node (object):
""" Node for a linked list. """
def __init__ (self, value, next=None):
self.value = value
self.next = next
class LinkedList (object):
""" Linked list ADT implementation using class.
A linked list is a wrapper of a head pointer
that references either None, or a node that contains
a reference to a linked list.
"""
def __init__ (self, iterable=()):
self.head = None
for x in iterable:
self.head = Node(x, self.head)
def __iter__ (self):
p = self.head
while p: # not None
yield p.value
p = p.next

def prepend (self, x): # 'appendleft'
self.head = Node(x, self.head)
def reverse (self):
""" In-place reversal. """
p = self.head
self.head = None
while p: # not None
p0 = p
p = p.next
p0.next = self.head
self.head = p0
if __name__ == '__main__':
ll = LinkedList([6,5,4])
ll.prepend(3); ll.prepend(2)
print list(ll)
ll.reverse()
print list(ll)

library

【在 n****1 的大作中提到】

c*o2013-01-12 08:01

24 楼

他说的其实不在点上，关键是第一要immutable, no variable,第二是recursion, no
loop
你再试试看。

【在 p**o 的大作中提到】

: 用类就行了。java和python都类似。
: class Node (object):
: """ Node for a linked list. """
: def __init__ (self, value, next=None):
: self.value = value
: self.next = next
: class LinkedList (object):
: """ Linked list ADT implementation using class.
: A linked list is a wrapper of a head pointer
: that references either None, or a node that contains

n*12013-01-12 08:01

25 楼

这个就是OO开始恶心人的地方了。在这个阶段就把所有与List有关的函数都绑在一
起了，那用户要加新的有关函数，不就得subclass或者做delegation?
我觉得实现List核心不在于你写的那串很长的成员函数，而在于List的trait。也就
是说把List变成MonadPlus. 这个只需要定义foldr, fmap与join, mzero, mplus就可以
了。
foldr:: (a->b->b)-> b -> [a] -> b
foldr f seed [] = seed
foldr f seed x:xs = f x (foldr f seed xs)
fmap:: (a-> m b) -> m a -> m b
fmap f li = foldr ((:).f) [] li
join:: (m (m a) )-> m a
join li = foldr ++ [] li
mzero = []
mplus = ++
++ la lb = foldr (:) lb la

【在 c******o 的大作中提到】

: 我写的和它类似，不过是没 implement eq/Ord
: sealed trait List[+A]
: case object Nil extends List[Nothing]
: case class Cons[+A] (head: A, tail: List[A]) extends List[A]
: object List {
: def apply[A](as: A*): List[A] =
: if (as.isEmpty) Nil
: else Cons(as.head, apply(as.tail: _*))
: private def asString_internal[A](l: List[A]): String =
: l match {

c*o2013-01-12 08:01

26 楼

你没看懂我的，我的就是这样，只不过没有把trait 拿出来。。。
再给你贴一个我的练习。
trait Functor[F[_]] {
def map[A,B](t: F[A])(f: A => B): F[B]
}
trait Applicative[F[_]] extends Functor[F]{
def unit[A](a: => A): F[A]
def ap[A,B](fa: F[A])(fab: F[A => B]): F[B]
override def map[A,B](t: F[A])(f: A => B): F[B] = ap(t)(unit(f))
}
trait Monad[F[_]] extends Applicative[F] {
def unit[A](a: => A): F[A]
def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B]
override def ap[A,B](la: F[A])(f: F[A => B]): F[B] =
flatMap(f)(t1 => flatMap(la)(t2 => unit(t1(t2))))
override def map[A,B](ma: F[A])(f: A => B): F[B] =
flatMap(ma)(a => unit(f(a)))
}
import scala.language.higherKinds
val OptionApplicatable = new Applicative[Option] {
def unit[A](a: => A) = Some(a)
def ap[A,B](a: Option[A])(f: Option[A => B]): Option[B] =
f.flatMap {
t1 => a.flatMap {
t2 => unit(t1(t2))
}
}
}
val OptionMonad = new Monad[Option] {
def unit[A](a: => A) = Some(a)
def flatMap[A,B](a: Option[A])(f: A => Option[B]): Option[B] =
a.flatMap(f)
}

【在 n****1 的大作中提到】

: 这个就是OO开始恶心人的地方了。在这个阶段就把所有与List有关的函数都绑在一
: 起了，那用户要加新的有关函数，不就得subclass或者做delegation?
: 我觉得实现List核心不在于你写的那串很长的成员函数，而在于List的trait。也就
: 是说把List变成MonadPlus. 这个只需要定义foldr, fmap与join, mzero, mplus就可以
: 了。
: foldr:: (a->b->b)-> b -> [a] -> b
: foldr f seed [] = seed
: foldr f seed x:xs = f x (foldr f seed xs)
: fmap:: (a-> m b) -> m a -> m b
: fmap f li = foldr ((:).f) [] li

n*12013-01-12 08:01

27 楼

有点奇怪， monad是functor/applicative的一种。应该是你定义好monad, 就不用定
义functor/applicative了吧。 Monad也只需要fmap和join啊。
没学过scala, 不懂
val OptionApplicatable = new Applicative[Option]
是干啥的，能解释下么？

【在 c******o 的大作中提到】

: 你没看懂我的，我的就是这样，只不过没有把trait 拿出来。。。
: 再给你贴一个我的练习。
: trait Functor[F[_]] {
: def map[A,B](t: F[A])(f: A => B): F[B]
: }
: trait Applicative[F[_]] extends Functor[F]{
: def unit[A](a: => A): F[A]
: def ap[A,B](fa: F[A])(fab: F[A => B]): F[B]
: override def map[A,B](t: F[A])(f: A => B): F[B] = ap(t)(unit(f))
: }

c*o2013-01-12 08:01

28 楼

我定义了一个option monad (也是applicative)
定义了一个applicative (不是monad)
这一行就是定义一个type是 applicative 里面的type是Option.
你当然可以再用它来做一个OptionApplicative instance
see, OO has nothing bad with FP, it just Imperative against FP

【在 n****1 的大作中提到】

: 有点奇怪， monad是functor/applicative的一种。应该是你定义好monad, 就不用定
: 义functor/applicative了吧。 Monad也只需要fmap和join啊。
: 没学过scala, 不懂
: val OptionApplicatable = new Applicative[Option]
: 是干啥的，能解释下么？

c*o2013-01-12 08:01

29 楼

in scala, type, type constructor, type classes are all kind of trait/class,
just with generics.
scala is almost as powerful as Haskell, just not pure

n*12013-01-12 08:01

30 楼

I think in an immutable world, the main disagreement over OOP is on the
modularity of libraries/functions, agree? OOP in FP just pack some functions
together in a class. While haskell just preserves a flat structure, and
provide modularity on file level.
I think trait is similar to typeclass in haskell. There is no class in
haskell.

,

【在 c******o 的大作中提到】

: in scala, type, type constructor, type classes are all kind of trait/class,
: just with generics.
: scala is almost as powerful as Haskell, just not pure

d*i2013-01-12 08:01

31 楼

看到Scala的Nil，就想到了肯定来自于Lisp的nil, 说实话还是喜欢C/C++/Java的NULL(
null)。数学上面的术语都是用null的，比如null space, null set, null hypothesis
等等，scala用nil的大概是受了lisp的影响，C系的和其他主流语言都是用NULL。

【在 c******o 的大作中提到】

n*12013-01-12 08:01

32 楼

还真不是， nil是针对object的， null是针对pointer/reference的. 参加Objective-
C(nil null都有。)

NULL(
hypothesis

【在 d****i 的大作中提到】

: 看到Scala的Nil，就想到了肯定来自于Lisp的nil, 说实话还是喜欢C/C++/Java的NULL(
: null)。数学上面的术语都是用null的，比如null space, null set, null hypothesis
: 等等，scala用nil的大概是受了lisp的影响，C系的和其他主流语言都是用NULL。

d*i2013-01-12 08:01

33 楼

obj-C不清楚，C++里面没有NULL引用，只能是NULL指针。不过貌似obj-C的nil本质上就
是NULL：
http://stackoverflow.com/questions/4283690/objective-c-whats-th

Objective-

【在 n****1 的大作中提到】

: 还真不是， nil是针对object的， null是针对pointer/reference的. 参加Objective-
: C(nil null都有。)
:
: NULL(
: hypothesis

e*o2013-01-12 08:01

34 楼

我的意思haskell的list 定义难看懂。
haskell 的优先级，$符号, 我也是搞了好久才明白。
可能我太笨，也可能这是haskell 流行不了的原因。
当然了，你可以说你会了就简单了...
library

n*12013-01-12 08:01

35 楼

我学的语言中感觉Lisp最难读懂，比如下面的call/cc例子，我花了十几天才想明白
。俺觉得觉得相对lisp来说， Haskell已经很标准易读了。
(define the-continuation #f)
(define (test)
(let ((i 0))
; call/cc calls its first function argument, passing
; a continuation variable representing this point in
; the program as the argument to that function.
;
; In this case, the function argument assigns that
; continuation to the variable the-continuation.
;
(call/cc (lambda (k) (set! the-continuation k)))
;
; The next time the-continuation is called, we start here.
(set! i (+ i 1))
i))
> (test)
1
> (the-continuation)
2
> (the-continuation)
3
> ; stores the current continuation (which will print 4 next) away
> (define another-continuation the-continuation)
> (test) ; resets the-continuation
1
> (the-continuation)
2
> (another-continuation) ; uses the previously stored continuation
4