Почему и как Монархия продолжения решает адский призыв? Другими словами: RX или FRP = продолжение Monad? ЕСЛИ не =, в чем разница?

Question

Here и here говорится, что Монако продолжения решает обратный ад.

RX и FRP также решают Адвокат обратного вызова.

Если все эти три инструмента решить Обры ад, то возникает следующий вопрос:

В видео Эрика говорят, что RX = Продолжение Монада. Это действительно так? Если да, можете ли вы показать отображение?

IF RX is not = Cont. Монада, тогда в чем разница между RX и Continuation Monad?

Аналогично, в чем разница между FRP и продолжением Monad?

Другими словами, предполагая, что читатель знает, что такое FRP или RX, как читатель может легко понять, что такое Continuation Monad?

Можно ли/легко понять, что такое Continuation Monad, сравнивая его с RX или FRP?

Answer 1

Я не знаком с RX, но относительно FRP и продолжения монады, они принципиально разные понятия.

Functional reactive programming - решение проблемы работы с зависящими от времени значениями и событиями. С помощью событий вы можете решить проблему обратного вызова, упорядочивая вычисления таким образом, чтобы при завершении события отправлялось событие и запускалось следующее. Но с обратными вызовами вы действительно не заботитесь о времени, вы просто хотите последовательно вычислять вычисления, поэтому, если ваша целая программа не основана на FRP, это не оптимальное решение.

continuation monad не имеет никакого отношения к времени вообще. Это абстрактная концепция вычислений, которая может (свободно говоря) принимать «моментальные снимки» текущей последовательности оценки и использовать их для «прыжка» на эти снимки произвольно. Это позволяет создавать сложные управляющие структуры, такие как петли и coroutines. Теперь рассмотрим определение продолжения монады:

newtype Cont r a = Cont { runCont :: (a -> r) -> r} 

Это по существу функция с обратным вызовом! Это функция, которая принимает продолжение (обратный вызов), который продолжит вычисление после создания a. Так что если у вас есть несколько функций, которые принимают продолжений,

f1 :: (Int -> r) -> r 

f2 :: Int -> (Char -> c) -> c 

f3 :: Char -> (String -> d) -> d 

их состав становится несколько неаккуратно:

comp :: String 
comp = f1 (\a -> f2 a (\b -> f3 b id)) 

Использование продолжений, он становится очень просто, нам нужно просто обернуть их в cont, а затем последовательно их используя монадические связывают >>= Отдела:

import Control.Monad.Cont 

comp' :: String 
comp' = runCont (cont f1 >>= cont . f2 >>= cont . f3) id 

Так продолжения являются прямым решением callbac k проблема.