История изменений

Асинхронное программирование: Future/Promise паттерн. Вроде бы, ты пишешь одну функцию, части которой раскиданы во времени, но фактически являются несколькими анонимными функциями, вызываемыми в некоторой последовательности или параллельно. Таким образом, у тебя получается неблокирующийся код без упоминания каких-либо thread/spawn и т.д.

def myfunction(arg: String): Future[Int] = {
  http_post("http://site.com/form/" + arg) flatMap {
    case 200 =>
      // сделать другой запрос. http_get() также возвращает Future[Int]
      http_get("http://site.com/ok/" + arg)
    case _ =>
      Future.failed(new Exception(...))
  }
}

• начинается http_post() который сразу вовзращает Future[Int] и уходит в фон. Вызывается flatMap(), которому передаётся лямбда. Функция myfunction() возвращает результат вызова flatMap() без выполнения тела переданной лямбды, т.е. значение типа Future[Int] (1). Тело лямбды как бы поставилось в очередь на выполнение. Далее, основной поток выполнения программы идёт куда-то дальше, возможно комбинирует полученный фьючерс (1) с другими лямбдами или делает что-то ещё, хотя http-запрос ещё возможно даже не начался.
• Через какое-то время выполнился первый запрос, из пула потоков достаётся поток и начинает выполнять лямбду, переданную во flatMap(). Лямбда имеет прозрачный для программиста доступ к данным внешней функции, которая уже давно завершилась. http_get() возвращает другой результат Future[Int] (2). Поток возвращается назад в пул потоков.
• Через ещё какое-то время выполнился второй запрос. Результат запроса отправляется в (2), который, благодаря flatMap(), отправляет это значение в (1).

Сейчас всё серверное программирование идёт в асинхрон для оптимизации нагрузки и снижения латентности (например, серверы finagle, twisted, play-framework, etc, etc), поэтому лямбды или какие-то другие инструменты очень нужны, чтобы писать асинхронно-работающий код, практически не усложняя его.

Асинхронное программирование: Future/Promise паттерн. Вроде бы, ты пишешь одну функцию, части которой раскиданы во времени, но фактически являются несколькими анонимными функциями, вызываемыми в некоторой последовательности или параллельно. Таким образом, у тебя получается неблокирующийся код без упоминания каких-либо thread/spawn и т.д.

def myfunction(arg: String): Future[Int] = {
  http_post("http://site.com/form/" + arg) flatMap {
    case 200 =>
      // сделать другой запрос. http_get() также возвращает Future[Int]
      http_get("http://site.com/ok/" + arg)
    case _ =>
      Future.failed(new Exception(...))
  }
}

• начинается http_post() который сразу вовзращает Future[Int] и уходит в фон. Вызывается flatMap(), которому передаётся лямбда. Функция myfunction() возвращает результат вызова flatMap() без выполнения самой лямбда, т.е. значение типа Future[Int] (1). Тело лямбды как бы поставилось в очередь на выполнение. Далее, основной поток выполнения программы идёт куда-то дальше, возможно комбинирует полученный фьючерс (1) с другими лямбдами или делает что-то ещё, хотя http-запрос ещё возможно даже не начался.
• Через какое-то время выполнился первый запрос, из пула потоков достаётся поток и начинает выполнять лямбду, переданную во flatMap(). Лямбда имеет прозрачный для программиста доступ к данным внешней функции, которая уже давно завершилась. http_get() возвращает другой результат Future[Int] (2). Поток возвращается назад в пул потоков.
• Через ещё какое-то время выполнился второй запрос. Результат запроса отправляется в (2), который, благодаря flatMap(), отправляет это значение в (1).

Сейчас всё серверное программирование идёт в асинхрон для оптимизации нагрузки и снижения латентности (например, серверы finagle, twisted, play-framework, etc, etc), поэтому лямбды или какие-то другие инструменты очень нужны, чтобы писать асинхронно-работающий код, практически не усложняя его.

Асинхронное программирование: Future/Promise паттерн. Вроде бы, ты пишешь одну функцию, части которой раскиданы во времени, но фактически являются несколькими анонимными функциями, вызываемыми в некоторой последовательности или параллельно. Таким образом, у тебя получается неблокирующийся код без упоминания каких-либо thread/spawn и т.д.

def myfunction(arg: String): Future[Int] = {
  http_post("http://site.com/form/" + arg) flatMap {
    case 200 =>
      // сделать другой запрос. http_get() также возвращает Future[Int]
      http_get("http://site.com/ok/" + arg)
    case _ =>
      Future.failed(new Exception(...))
  }
}

• начинается http_post() который сразу вовзращает Future[Int] и уходит в фон. Вызывается flatMap - функция myfunction() уже возвращает значение типа Future[Int] (1). Далее, основной поток выполнения идёт дальше по программе, комбинирует (1) с другими лямбдами или делает что-то ещё, хотя http-запрос ещё даже толком не начался.
• Через какое-то время выполнился первый запрос, из пула потоков достаётся поток и начинает выполнять лямбду, переданную во flatMap. Лямбда имеет прозрачный для программиста доступ к внешним данным. http_get() возвращает другой результат Future[Int] (2). Поток возвращается назад в пул потоков.
• Через ещё какое-то время выполнился второй запрос. Результат запроса отправляется в (2), который, благодаря flatMap, отправляет это значение в (1).

Сейчас всё серверное программирование идёт в асинхрон для оптимизации нагрузки и снижения латентности (серверы finagle, twisted, play-framework, etc, etc), поэтому лямбды или какие-то другие инструменты очень нужны, чтобы писать асинхронно-работающий код, практически не усложняя его