Why Reactor Mono is recognized as an empty Mono?

Question

Here is the piece of code

@Test
public void test_mono_void_mono_empty() {
    Mono.just("DATA")
        .flatMap(s -> Mono.just(s.concat("-")
                                 .concat(s))
                          .doOnNext(System.out::println)
                          .then())
        .switchIfEmpty(Mono.just("EMPTY")
                           .doOnNext(System.out::println)
                           .then())
        .block();
}

that gives the following result to the console:

DATA-DATA
EMPTY

That means that the chain in the first flatMap was recognized as an empty one.

On the other hand Reactor has the following class MonoEmpty that is returned by a Mono.empty() method. On top of that, the method says the following:

/**
 * Create a {@link Mono} that completes without emitting any item.
 *
 * <p>
 * <img class="marble" src="doc-files/marbles/empty.svg" alt="">
 * <p>
 * @param <T> the reified {@link Subscriber} type
 *
 * @return a completed {@link Mono}
 */
public static <T> Mono<T> empty() {
    return MonoEmpty.instance();
}

without emitting any item - but I emitted Void typed object with then() method.

What is the explanation of that?

`s.concat("-").concat(s)` should probably be written as `s + "-" + s` — Lino, Dec 05 '19 at 13:52
`+` can be optimized by the compiler whereas with `concat()` you have no such guarantee: https://stackoverflow.com/a/47626/5515060 — Lino, Dec 05 '19 at 14:00
I meant no difference in the scope of the question. How is it related to the topic? — Serhii Povísenko, Dec 05 '19 at 14:06
It is not, but does it have to be? I just simply proposed an improvement — Lino, Dec 05 '19 at 14:28

score 11 · Answer 1 · answered Dec 07 '19 at 17:38

A given Mono can publish either nothing, or a single value before sending a completion signal. (It can't publish null - the reactive spec forbids it.) The generic type of the Mono denotes the type of the object that might be emitted - but there's no guarantee it will be emitted.

A Mono<Foo> for example can emit just a completion signal, or an instance of Foo and then a completion signal.

There's two common scenarios where a value may not be published - the first is if a value may or may not exist (such as searching for an item in a database or collection). In that case, you'd still use a Mono<SomeType>, and it may or may not emit a SomeType instance. The second scenario is if a value will definitely never be published (often used when you just need notification that a task has completed), and for that, by convention, Mono<Void> is always used. then(), in your above example, falls into the second case.

The reason that Mono<Void> is a special case is that, as you point out, Void is a class that can never be instantiated by design. There's therefore no such thing as an instance of Void, which means the Mono can never emit a value before its completion signal.

The logical conclusion therefore is that a publisher of type Mono<Void> can never emit a value, only a completion signal - and so it is used as such.

Serhii Povísenko · Accepted Answer · 2019-12-05T13:50:13.813

10

Okay, the answer is in the official java doc that says The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void.

That means that its main idea is simply to represent the void return type as a class and contain a Class<Void> public value. That's it. Besides, it's not instantiable as the constructor is private. All of that subsequently means that the only value we can assign to a Void variable is null what always is recognized as empty Mono.

helpful discussion: Java generics void/Void types

edited Dec 05 '19 at 13:50

answered Dec 05 '19 at 13:42

Serhii Povísenko

3,352
1
30
48

5

"the only value we can assign to a Void variable is null what always is recognized as empty Mono" - careful with that; it may be subtly missing what's happening here. You can't propagate null through a reactive stream at all, but you *can* simply propagate nothing at all before a completion signal (which a `Mono` implies.) – Michael Berry Dec 08 '19 at 18:00

Why Reactor Mono is recognized as an empty Mono?

2 Answers2