All Java engineers know about classes, in particular about POJO.
We writing POJO's every time we need some set of related named variables.
Tuple
is a data structure which is very similar to Java POJO - it contains few variables with respective types. The difference is that Tuple
contains unnamed values unlike POJO. Tuple
also similar to arrays, except that elements may have different types and properly implemented Tuple
must preserve those types.
Tuple
is often implemented as a Monad, i.e. there is no accessors and therefore there is no way to get single element. In fact there is no big sense to have accessors for Tuple
. Since elements have no names, accessors would operate with ordinals of elements, which is error-prone and inconvenient.
Fortunately Monad
-based implementation of Tuple
allows to provide convenient way to access all elements at once (and even give those elements arbitrary names) - map()
method which accepts lambda with number of parameters equal to Tuple
size.
Provided below small example shows how this looks like:
final var tuple = Tuple.with(10, "some string", UUID.randomUUID());
tuple.map((integer, string, uuid) -> System.out.printf("Received: %d, %s, %s", integer, string, uuid));
The lambda invoked by map()
has access to all components at once and can produce arbitrary result. Note that if there is an POJO, which has all-args constructor with matching parameter order, then Tuple
can be converted to POJO in one step:
public class SimplePojo {
private final Integer intValue;
private final String stringValue;
private final UUID uuidValue;
public SimplePojo(final Integer intValue, final String stringValue, final UUID uuidValue) {
...
}
...
}
...
final var tuple = Tuple.with(10, "some string", UUID.randomUUID());
final var pojo = tuple.map(SimplePojo::new);
Of course, factory method will work too.
The Tuple
is convenient in a number of areas, especially those where structure of the complex piece of data can't be defined upfront. In particular this is true for general purpose API's.
Another area is returning several values from the method call. Here Tuple
is especially convenient - map()
enables destructuring very similar to languages which have this feature built in:
...
Tuple3<Integer, String, UUID> parseParameters(final Request request);
...
Result<ResponsePojo> serveRequest(final Integer count, final String message, final UUID userId);
...
return parseRequest(request)
.map((count, message, uuid) -> serveRequest(count, message, uuid));
The Reactive Toolbox Core uses Tuple
in cases when several results should be grouped together, for example when there is a need to return result of waiting of several Promise
's to be resolved:
<T1, T2, T3> Promise<Tuple3<T1, T2, T3>> all(final Promise<T1> promise1,
final Promise<T2> promise2,
final Promise<T3> promise3);
The method above will wait for resolution of 3 Promise
's and then return all values in single Tuple
with 3 elements.
Top comments (1)
Thank you for a good article