Haskell 连续抽象

在基于此的并发性的一般练习中

我们有：

-- a is the result type on which after we continue
type Continuation a = a-> Action

type ContinuationPseudoMonad a = Continuation a -> Action
-- pseudoMonad because it will need Concurrent wrapper Monad:
-- so as to define bind operation and return operation on it

data Concurrent a = Concurrent (ContinuationPseudoMonad a)

因此，

并发a

是一个单子，我们必须使用它的两个强制性法律，return和bind来实现

不幸的是，我找不到足够的词汇来更精确地定义ContinuationPseudoMonad这件事。。。如果我缺乏语言，我的头脑中就缺乏抽象

你怎么称呼它

有没有一个词的意思是

Continuation a->Action

而不是我那笨拙的、毫无意义的

Continuation假单胞菌

行动是：

data Action = Atom (IO Action)
            | Fork Action Action
            | Stop

---

你似乎在学习一些词汇，这是一个很难表达的问题。让我们把你所拥有的分解成几个步骤，看看这是否有帮助

data Action = Atom (IO Action)
            | Fork Action Action
            | Stop

Action

是一种代数数据类型，具有三个构造函数。它是一种corecursive数据类型，因为它是根据自身定义的

type Continuation a = a -> Action

延续a

是函数类型

a->Action

的类型别名。这是一个反变函子的例子，因为我们可以定义一个函数

contramap :: (a -> b) -> Continuation b -> Continuation a
contramap aToB bToAction = aToAction 
  where aToAction = \a -> bToAction (aToB a)

fmap :: (a -> b) -> ContinuationPseudoMonad a -> ContinuationPseudoMonad b
fmap aToB aToActionToAction = bToActionToAction
  where bToActionToAction = \bToAction -> aToActionToAction (\a -> bToAction (aToB a))

注意，反转-

contracemap

采用函数

a->b

，并创建函数

Continuation b->Continuation a

type ContinuationPseudoMonad a = Continuation a -> Action

ContinuationPseudoMonad a

是函数类型的另一种类型别名，但由于

Continuation a

也是一种函数类型，

ContinuationPseudoMonad a

是一种高阶函数，因为它将函数作为参数

ContinuationPseudoMonad a

也是一个函子，但它是一个协变函子，因为我们可以定义一个函数

contramap :: (a -> b) -> Continuation b -> Continuation a
contramap aToB bToAction = aToAction 
  where aToAction = \a -> bToAction (aToB a)

fmap :: (a -> b) -> ContinuationPseudoMonad a -> ContinuationPseudoMonad b
fmap aToB aToActionToAction = bToActionToAction
  where bToActionToAction = \bToAction -> aToActionToAction (\a -> bToAction (aToB a))

---

你似乎在学习一些词汇，这是一个很难表达的问题。让我们把你所拥有的分解成几个步骤，看看这是否有帮助

data Action = Atom (IO Action)
            | Fork Action Action
            | Stop

Action

是一种代数数据类型，具有三个构造函数。它是一种corecursive数据类型，因为它是根据自身定义的

type Continuation a = a -> Action

延续a

是函数类型

a->Action

的类型别名。这是一个反变函子的例子，因为我们可以定义一个函数

contramap :: (a -> b) -> Continuation b -> Continuation a
contramap aToB bToAction = aToAction 
  where aToAction = \a -> bToAction (aToB a)

fmap :: (a -> b) -> ContinuationPseudoMonad a -> ContinuationPseudoMonad b
fmap aToB aToActionToAction = bToActionToAction
  where bToActionToAction = \bToAction -> aToActionToAction (\a -> bToAction (aToB a))

注意，反转-

contracemap

采用函数

a->b

，并创建函数

Continuation b->Continuation a

type ContinuationPseudoMonad a = Continuation a -> Action

ContinuationPseudoMonad a

是函数类型的另一种类型别名，但由于

Continuation a

也是一种函数类型，

ContinuationPseudoMonad a

是一种高阶函数，因为它将函数作为参数

ContinuationPseudoMonad a

也是一个函子，但它是一个协变函子，因为我们可以定义一个函数

contramap :: (a -> b) -> Continuation b -> Continuation a
contramap aToB bToAction = aToAction 
  where aToAction = \a -> bToAction (aToB a)

fmap :: (a -> b) -> ContinuationPseudoMonad a -> ContinuationPseudoMonad b
fmap aToB aToActionToAction = bToActionToAction
  where bToActionToAction = \bToAction -> aToActionToAction (\a -> bToAction (aToB a))

---

显然，

Concurrent a

与

Cont Action a

相同，其中是continuation monad。下面是一个关于延续的简单解释：

对于某些任意类型的

a

和

b

，请考虑函数

f:：a->b

。我们希望将此函数转换为连续传递样式。我们如何做到这一点

假设我们有一个continuation

k:：b->r

，它将

f

的返回值作为输入，并且自身返回任意类型的值

r

。接下来，我们可以将

f

转换为CPS

让

g:：a->（b->r）->r

成为

f

的CPS版本函数。请注意，它接受一个附加参数（即continuation

k

），并返回应用于其输出

b

的

k

的结果

让我们举一个实际的例子，其中

f

是谓词函数

odd:：Int->Bool

：

odd:：Int->Bool
奇数n=n`mod`2==1

以下是以连续传递样式编写的相同函数：

odd'：：Int->（Bool->r）->r
奇数'nk=k（n'mod'2==1）

（Bool->r）->r

部分可以抽象为延续单子：

datacontra=Cont{runCont:：（a->r）->r}
奇数'：：Int->Cont r Bool
奇数n=return（n`mod`2==1）
实例Monad（续）其中
返回a=Cont（\k->ka）
m>>=f=Cont（\k->runCont m（\a->runCont（fa）k））

注意，对于某些任意类型的

r

，延续

k

的类型是

Bool->r

。因此，continuation

k

可以是以

Bool

为参数的任何函数。例如：

cont:：Bool->IO（）
cont=打印
main:：IO（）
主=奇数'21续

但是，在

并发

的情况下，此

r

不是任意的。它专门用于

操作

。事实上，我们可以将

Concurrent

定义为

contaction

的类型同义词，如下所示：

type Concurrent=Cont Action

现在，我们不需要为

Concurrent

实现

Monad

实例，因为它与上面定义的

contr

的

Monad

实例相同

runConcurrent:：Concurrent a->ContinuationPseudoMonad a
runConcurrent（Concurrent g）=g
实例Monad并发在哪里
返回a=Concurrent（\k->ka）
m>>=f=Concurrent（\k->runConcurrent m（\a->runConcurrent（fa）k））

---

请注意，在

实例Monad Concurrent

的定义中，我们没有使用

操作

。这是因为

Concurrent=contaction

和

contr

的monad实例透明地使用

r

。

很明显

Concurrent a

与

contaction a

相同，其中是延续monad。下面是一个关于延续的简单解释：

对于某些任意类型的

a

和

b

，请考虑函数

f:：a->b

。我们希望将此函数转换为连续传递样式。我们如何做到这一点

假设我们有一个continuation

k:：b->r

，它接受

f的返回值