В чем разница между реактивным программированием и простыми старыми замыканиями?

Question

Пример из scala.rx:

import rx._
val a = Var(1); val b = Var(2)
val c = Rx{ a() + b() }
println(c()) // 3
a() = 4
println(c()) // 6

Чем выше версия лучше чем:

var a = 1; var b = 2
def c = a + b
println(c) // 3
a = 4
println(c) // 6

Единственное, о чем я могу думать, это то, что первый пример эффективен в том смысле, что если a или же b изменения, c не пересчитывается, но в моей версии, c пересчитывается каждый раз, когда я призываю c() но это только особый случай запоминания с размером =1, например, я могу сделать это, чтобы предотвратить повторные вычисления, используя макрос запоминания:

var a = 1; var b = 2
@memoize(maxSize = 1) def c(x: Int = a, y: Int = z) = x + y

Есть ли что-то, чего мне не хватает в реактивном программировании, которое дает представление о том, почему в некоторых случаях это может быть лучшая парадигма (чем запомненные замыкания)?

Answer 1

Проблема: это плохой пример

Пример на веб-странице не очень хорошо иллюстрирует назначение Scala.RX. В этом смысле это довольно плохой пример.

Для чего нужен Scala.RX?

Это об уведомлениях

Идея Scala.Rs заключается в том, что фрагмент кода может получать уведомления при изменении данных. Обычно это уведомление используется для (повторного) расчета результата, который зависит от измененных данных.

Scala.RX автоматизирует проводку

Когда вычисления проходят несколько этапов, становится довольно трудно отследить, какой промежуточный результат зависит от того, от каких данных и каких других промежуточных результатов. Дополнительно необходимо пересчитать промежуточные результаты в правильном порядке.

Вы можете думать об этом, как о большом листе Excel, который должен иметь формулы, которые зависят друг от друга. Когда вы меняете одно из входных значений, Excel должен выяснить, какие части листа должны быть пересчитаны и в каком порядке. Когда Excel пересчитает все измененные ячейки, он может обновить отображение.

Scala.RX может делать то же самое, что и Excel: он отслеживает зависимость формул друг от друга, уведомляет те, которые необходимо обновить в правильном порядке.

Назначение: MVC

Scala.RX - это хороший инструмент для реализации MVC-паттерна, особенно если у вас есть бизнес-приложения, которые вы также можете использовать для превосходства.

Есть также вариант, который работает с Scala.js, то есть он запускается в браузере как часть HTML-сайта. Это может быть очень полезно, если вы хотите динамически обновлять части HTML-страницы в соответствии с изменениями на сервере или изменениями пользователя.

Ограничения

Scala.RX не масштабируется, когда у вас есть огромное количество входных данных, например, операции с огромными матрицами.

Лучший пример

import rx._
import rx.ops._

val a = Var(1); val b = Var(2)
val c: Rx[Int] = Rx{ a() + b() }

val o = c.foreach{value =>
  println(s"c has a new value: ${value}")
}

a()=4
b()=12
a()=35

Дает вам следующий вывод:

с имеет новое значение: 3 
с имеет новое значение: 6 
с имеет новое значение: 16 
с имеет новое значение: 47

Теперь представьте, что вместо печати значения вы обновите элементы управления в пользовательском интерфейсе или частях HTML-страницы.