Объект Future.Future

объект Future

Объект-компаньон для Future.

Классы-конструкторы

Исходный код

объект never extends Future[Nothing]

Future, который никогда не завершается.

Конкретные методы

Исходный код

final def apply[T](body: => T)(implicit executor: ExecutionContext): Future[T]

Запускает асинхронное вычисление и возвращает экземпляр Future с результатом этого вычисления.

Следующие выражения эквивалентны:

val f1 = Future(expr)
val f2 = Future.unit.map(_ => expr)
val f3 = Future.unit.transform(_ => Success(expr))

Результат становится доступным после завершения асинхронного вычисления.

Исходный код

final def delegate[T](body: => Future[T])(implicit executor: ExecutionContext): Future[T]

Запускает асинхронное вычисление и возвращает экземпляр Future с результатом вычисления после его завершения.

Следующие выражения семантически эквивалентны:

val f1 = Future(expr).flatten
val f2 = Future.delegate(expr)
val f3 = Future.unit.flatMap(_ => expr)

Результат становится доступным после завершения результирующего Future асинхронного вычисления.

Исходный код

final def failed[T](exception: Throwable): Future[T]

Создаёт уже завершённый Future с указанной исключительной ситуацией.

Исходный код

final def find[T](futures: Iterable[Future[T]])(p: T => Boolean)(implicit executor: ExecutionContext): Future[Option[T]]

Асинхронно и без блокировки возвращает Future, который будет содержать необязательный результат первого Future с результатом, соответствующим предикату; провалы Future будут игнорироваться.

Исходный код

final def firstCompletedOf[T](futures: IterableOnce[Future[T]])(implicit executor: ExecutionContext): Future[T]

Асинхронно и без блокировки возвращает новый Future к результату первого завершенного будущего в списке. Это означает, что независимо от того, завершилось ли оно успешно или с ошибкой.

Исходный код

final def foldLeft[T, R](futures: Iterable[Future[T]])(zero: R)(op: (R, T) => R)(implicit executor: ExecutionContext): Future[R]

Неблокирующее, асинхронное левое свёртку над указанными будущими значениями, со начальным значением заданным zero. Свёртка выполняется асинхронно слева направо по мере завершения будущих значений. Результатом будет первая ошибка любого из будущих значений, или любая ошибка в фактической свёртке, или результат свёртки.

Пример:

val futureSum = Future.foldLeft(futures)(0)(_ + _)

Исходный код

final def fromTry[T](result: Try[T]): Future[T]

Создаёт уже завершенное будущее с указанным результатом или исключением.

Исходный код

final def reduceLeft[T, R >: T](futures: Iterable[Future[T]])(op: (R, T) => R)(implicit executor: ExecutionContext): Future[R]

Инициирует неблокирующую, асинхронную левую редукцию над предоставленными будущими значениями, где ноль — это значение результата первого Future

Пример:

val futureSum = Future.reduceLeft(futures)(_ + _)

Исходный код

final def sequence[A, CC <: (IterableOnce), To](in: CC[Future[A]])(implicit bf: BuildFrom[CC[Future[A]], A, To], executor: ExecutionContext): Future[To]

Простая версия Future.traverse. Асинхронно и без блокировки преобразует, по сути, IterableOnce[Future[A]] в Future[IterableOnce[A]]. Полезно для уменьшения многих Future в одно Future.

Исходный код

final def successful[T](result: T): Future[T]

Создает уже завершенный Future с указанным результатом.

Исходный код

final def traverse[A, B, M <: (IterableOnce)](in: M[A])(fn: A => Future[B])(implicit bf: BuildFrom[M[A], B, M[B]], executor: ExecutionContext): Future[M[B]]

Асинхронно и без блокировки преобразует IterableOnce[A] в Future[IterableOnce[B]] с помощью предоставленной функции A => Future[B]. Это полезно для выполнения параллельной карты. Например, чтобы применить функцию ко всем элементам списка параллельно:

val myFutureList = Future.traverse(myList)(x => Future(myFunc(x)))

Конкретные поля

Исходный код

final val unit: Future[Unit]

Future, который завершается со значением Unit.