Test two objects for inequality.
true
if !(this == that), false otherwise.
Equivalent to x.hashCode
except for boxed numeric types and null
. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null
returns a hashcode where null.hashCode
throws a NullPointerException
.
a hash value consistent with ==
The expression x == that
is equivalent to if (x eq null) that eq null else x.equals(that)
.
true
if the receiver object is equivalent to the argument; false
otherwise.
Starts an asynchronous computation and returns a Future
instance with the result of that computation.
The following expressions are equivalent:
val f1 = Future(expr) val f2 = Future.unit.map(_ => expr) val f3 = Future.unit.transform(_ => Success(expr))
The result becomes available once the asynchronous computation is completed.
the type of the result
the asynchronous computation
the execution context on which the future is run
the Future
holding the result of the computation
Cast the receiver object to be of type T0
.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String]
will throw a ClassCastException
at runtime, while the expression List(1).asInstanceOf[List[String]]
will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.
the receiver object.
ClassCastException
if the receiver object is not an instance of the erasure of type T0
.
Create a copy of the receiver object.
The default implementation of the clone
method is platform dependent.
a copy of the receiver object.
Starts an asynchronous computation and returns a Future
instance with the result of that computation once it completes.
The following expressions are semantically equivalent:
val f1 = Future(expr).flatten val f2 = Future.delegate(expr) val f3 = Future.unit.flatMap(_ => expr)
The result becomes available once the resulting Future of the asynchronous computation is completed.
the type of the result
the asynchronous computation, returning a Future
the execution context on which the body
is evaluated in
the Future
holding the result of the computation
Tests whether the argument (that
) is a reference to the receiver object (this
).
The eq
method implements an equivalence relation on non-null instances of AnyRef
, and has three additional properties:
x
and y
of type AnyRef
, multiple invocations of x.eq(y)
consistently returns true
or consistently returns false
.For any non-null instance x
of type AnyRef
, x.eq(null)
and null.eq(x)
returns false
.
null.eq(null)
returns true
. When overriding the equals
or hashCode
methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).
true
if the argument is a reference to the receiver object; false
otherwise.
The equality method for reference types. Default implementation delegates to eq
.
See also equals
in scala.Any.
true
if the receiver object is equivalent to the argument; false
otherwise.
Creates an already completed Future with the specified exception.
the type of the value in the future
the non-null instance of Throwable
the newly created Future
instance
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize
method is invoked, as well as the interaction between finalize
and non-local returns and exceptions, are all platform dependent.
Asynchronously and non-blockingly returns a Future
that will hold the optional result of the first Future
with a result that matches the predicate, failed Future
s will be ignored.
the type of the value in the future
the scala.collection.immutable.Iterable
of Futures to search
the predicate which indicates if it's a match
the Future
holding the optional result of the search
Asynchronously and non-blockingly returns a new Future
to the result of the first future in the list that is completed. This means no matter if it is completed as a success or as a failure.
the type of the value in the future
the IterableOnce
of Futures in which to find the first completed
the Future
holding the result of the future that is first to be completed
A non-blocking, asynchronous left fold over the specified futures, with the start value of the given zero. The fold is performed asynchronously in left-to-right order as the futures become completed. The result will be the first failure of any of the futures, or any failure in the actual fold, or the result of the fold.
Example:
val futureSum = Future.foldLeft(futures)(0)(_ + _)
the type of the value of the input Futures
the type of the value of the returned Future
the scala.collection.immutable.Iterable
of Futures to be folded
the start value of the fold
the fold operation to be applied to the zero and futures
the Future
holding the result of the fold
Creates an already completed Future with the specified result or exception.
the type of the value in the Future
the result of the returned Future
instance
the newly created Future
instance
Returns the runtime class representation of the object.
a class object corresponding to the runtime type of the receiver.
The hashCode method for reference types. See hashCode in scala.Any.
the hash code value for this object.
Test whether the dynamic type of the receiver object is T0
.
Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String]
will return false
, while the expression List(1).isInstanceOf[List[String]]
will return true
. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.
true
if the receiver object is an instance of erasure of type T0
; false
otherwise.
Equivalent to !(this eq that)
.
true
if the argument is not a reference to the receiver object; false
otherwise.
Wakes up a single thread that is waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
Wakes up all threads that are waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
Initiates a non-blocking, asynchronous, left reduction over the supplied futures where the zero is the result value of the first Future
.
Example:
val futureSum = Future.reduceLeft(futures)(_ + _)
the type of the value of the input Futures
the type of the value of the returned Future
the scala.collection.immutable.Iterable
of Futures to be reduced
the reduce operation which is applied to the results of the futures
the Future
holding the result of the reduce
Simple version of Future.traverse
. Asynchronously and non-blockingly transforms, in essence, a IterableOnce[Future[A]]
into a Future[IterableOnce[A]]
. Useful for reducing many Future
s into a single Future
.
the type of the value inside the Futures
the type of the IterableOnce
of Futures
the type of the resulting collection
the IterableOnce
of Futures which will be sequenced
the Future
of the resulting collection
Creates an already completed Future with the specified result.
the type of the value in the future
the given successful value
the newly created Future
instance
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
a String representation of the object.
Asynchronously and non-blockingly transforms a IterableOnce[A]
into a Future[IterableOnce[B]]
using the provided function A => Future[B]
. This is useful for performing a parallel map. For example, to apply a function to all items of a list in parallel:
val myFutureList = Future.traverse(myList)(x => Future(myFunc(x)))
the type of the value inside the Futures in the collection
the type of the value of the returned Future
the type of the collection of Futures
the collection to be mapped over with the provided function to produce a collection of Futures that is then sequenced into a Future collection
the function to be mapped over the collection to produce a collection of Futures
the Future
of the collection of results
© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.13.0/scala/concurrent/Future$.html
Future companion object.