### Install and Sync Dependencies with uv

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/README.md

Installs Python, creates a virtual environment, and synchronizes all development dependencies using the 'uv' tool. This is the initial setup step for the project.

```shell
uv python install
uv venv
source .venv/bin/activate
uv sync --all-extras --dev
```

--------------------------------

### Serve MkDocs Website Locally

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/README.md

Starts the MkDocs development server to preview the project's documentation website. This command should be run from the 'documentation/' directory.

```shell
uv run mkdocs serve
```

--------------------------------

### Add Mutiny to Quarkus project

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/getting-mutiny.md

Demonstrates how to add the Mutiny extension to a Quarkus project using the command-line interface or by manually updating the project's POM file.

```bash
mvn quarkus:add-extension -Dextensions=mutiny
```

```xml
<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-mutiny</artifactId>
</dependency>
```

--------------------------------

### Join Multiple Unis with Various Strategies (Java)

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Illustrates different ways to join multiple Uni objects using `Uni.join()`. Strategies include collecting all results (even failures), failing fast if any Uni fails, or selecting the first Uni to complete. It also shows how to get the first Uni that emits an item, ignoring failures until all have failed.

```java
import io.smallrye.mutiny.Uni;
import java.util.List;

Uni<Integer> a = Uni.createFrom().item(1);
Uni<Integer> b = Uni.createFrom().item(2);
Uni<Integer> c = Uni.createFrom().item(3);

// Join all and collect (waits for all, collects failures)
Uni<List<Integer>> allResults = Uni.join().all(a, b, c).andCollectFailures();
System.out.println(allResults.await().indefinitely()); // Output: [1, 2, 3]

// Join all with fail-fast (fails immediately if any fails)
Uni<List<Integer>> failFast = Uni.join().all(a, b, c).andFailFast();

// Get first to complete
Uni<Integer> firstToComplete = Uni.join().first(a, b, c).toTerminate();

// Get first to emit a value (ignores failures until all fail)
Uni<Integer> firstWithValue = Uni.join().first(a, b, c).withItem();
```

--------------------------------

### Java Example: Comparing Uni and Multi Usage

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/reference/uni-and-multi.md

This Java code snippet demonstrates the usage of Uni and Multi reactive types in SmallRye Mutiny. It illustrates how to create, subscribe to, and handle events from both types, highlighting their asynchronous nature and distinct event handling mechanisms.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

import static org.junit.jupiter.api.Assertions.*;

public class UniMultiComparisonTest {

    @Test
    public void testUni() {
        Uni<String> uni = Uni.createFrom().item("Hello");

        AtomicReference<String> result = new AtomicReference<>();
        uni.subscribe().with(result::set, failure -> fail("Unexpected failure"));

        assertEquals("Hello", result.get());
    }

    @Test
    public void testMulti() {
        List<String> items = Arrays.asList("A", "B", "C");
        Multi<String> multi = Multi.createFrom().iterable(items);

        List<String> collectedItems = multi.collect().asList().await().indefinitely();

        assertEquals(items, collectedItems);
    }

    @Test
    public void testUniFailure() {
        Uni<String> uni = Uni.createFrom().failure(new RuntimeException("Test failure"));

        AtomicReference<Throwable> failure = new AtomicReference<>();
        uni.subscribe().with(success -> fail("Unexpected success"), failure::set);

        assertNotNull(failure.get());
        assertEquals("Test failure", failure.get().getMessage());
    }

    @Test
    public void testMultiCompletion() {
        Multi<String> multi = Multi.createFrom().<String>empty()
                .onCompletion().fail().with(new IllegalStateException("Expected completion"));

        AtomicReference<Throwable> failure = new AtomicReference<>();
        multi.subscribe().with(success -> fail("Unexpected success"), failure::set);

        assertNotNull(failure.get());
        assertEquals("Expected completion", failure.get().getMessage());
    }

    @Test
    public void testUniWithNull() {
        Uni<String> uniWithNull = Uni.createFrom().item((String) null);

        AtomicReference<String> result = new AtomicReference<>();
        uniWithNull.subscribe().with(result::set, failure -> fail("Unexpected failure"));

        assertNull(result.get());
    }

    // Multi does not allow nulls according to Reactive Streams spec
    // The following would typically result in an error or be disallowed.
    // This test is illustrative of the constraint.
    @Test
    public void testMultiNullConstraint() {
        // Attempting to create a Multi with null would usually be an error
        // For demonstration, we'll show a Multi that emits non-nulls and completes.
        Multi<String> multi = Multi.createFrom().items("A", "B");
        List<String> collected = multi.collect().asList().await().indefinitely();
        assertEquals(Arrays.asList("A", "B"), collected);
    }
}
```

--------------------------------

### Java: Transform Item to Multi (Duplicate)

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/transforming-items-asynchronously.md

Shows how to transform a single item from a Uni into a Multi, effectively creating a stream from a single value. This example duplicates the incoming item to create a Multi emitting two identical items.

```java
Uni.createFrom().item("hello")
    .onItem().transformToMulti(item -> Multi.createFrom().items(item, item))
    .subscribe().with(result -> System.out.println("Received: " + result));
```

--------------------------------

### Suspicious reactive method implementation

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/reference/going-reactive-a-few-pitfalls.md

An example of a method returning a Uni that lacks actual asynchronous I/O, highlighting a common anti-pattern in reactive library usage.

```java
public Uni<String> getSuspiciousData() {
    return Uni.createFrom().item("data");
}
```

--------------------------------

### Implement Fallback Strategies for Timeouts

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/handling-timeouts.md

Provides examples of using fallback mechanisms when a timeout occurs, allowing the developer to return a default item or switch to an alternative Uni.

```java
// Fallback to a static item
uni.ifNoItem().after(Duration.ofSeconds(1)).recoverWithItem("default");

// Fallback to another Uni
uni.ifNoItem().after(Duration.ofSeconds(1)).recoverWithUni(otherUni);
```

--------------------------------

### Retry failed operations with backoff and deadlines

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Shows how to implement automatic retries for failed operations. Includes examples of simple retry counts, exponential backoff with jitter, and time-based expiration.

```java
import io.smallrye.mutiny.Uni;
import java.time.Duration;

// Simple retry with max attempts
Uni<String> withRetry = Uni.createFrom().item(() -> "Success")
    .onFailure().retry().atMost(5);

// Retry with exponential backoff
Uni<String> withBackoff = Uni.createFrom()
    .failure(new RuntimeException("Temporary error"))
    .onFailure().retry()
        .withBackOff(Duration.ofMillis(100), Duration.ofSeconds(1))
        .withJitter(0.2)
        .atMost(5);

// Retry with deadline
Uni<String> withDeadline = Uni.createFrom()
    .failure(new RuntimeException("Error"))
    .onFailure().retry()
        .withBackOff(Duration.ofMillis(100))
        .expireIn(5000);
```

--------------------------------

### Java: Transform Item to Multi (Conditional)

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/transforming-items-asynchronously.md

Demonstrates transforming a Uni item into a Multi based on a condition. This example creates a Multi that emits the item twice if it's not null, otherwise, it emits nothing.

```java
Uni.createFrom().optional(Optional.of("hello"))
    .onItem().transformToMulti(optional -> optional.isPresent() ? Multi.createFrom().items(optional.get(), optional.get()) : Multi.createFrom().empty())
    .subscribe().with(result -> System.out.println("Received: " + result));
```

--------------------------------

### Process Multi as Kotlin Flow

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/kotlin.md

This example shows how to process a Mutiny Multi as a Kotlin Flow. While Kotlin's Flow lacks full reactive streams flow control, this conversion allows for coroutine-based consumption of Multi items, with configurable buffering.

```kotlin
{{ insert('kotlin/guides/Coroutines.kt', 'multiAsFlow') }}
```

--------------------------------

### Create and Subscribe to a Uni in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/hello-mutiny.md

This Java code snippet demonstrates the creation of a Mutiny Uni that emits a single string item. It then applies transformations (appending ' mutiny' and converting to uppercase) to this item within a processing pipeline. Finally, it subscribes to the pipeline to consume the processed item and print it to the console. This illustrates the basic reactive programming pattern in Mutiny.

```java
import io.smallrye.mutiny.Uni;

public class FirstProgram {

    public static void main(String[] args) {
        Uni.createFrom().item("hello")
            .onItem().apply(s -> s + " mutiny")
            .onItem().apply(String::toUpperCase)
            .subscribe().with(System.out::println);
    }
}
```

--------------------------------

### Add Vert.x Mutiny bindings dependency

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/getting-mutiny.md

Configures dependencies for SmallRye Mutiny Vert.x bindings, allowing the use of Mutiny with Eclipse Vert.x modules. Supports Maven, Gradle, and JBang build environments.

```xml
<dependency>
    <groupId>io.smallrye.reactive</groupId>
    <artifactId>smallrye-mutiny-vertx-core</artifactId>
    <version>{{ attributes.versions.vertx_bindings }}</version>
</dependency>
```

```groovy
implementation 'io.smallrye.reactive:smallrye-mutiny-vertx-core:{{ attributes.versions.vertx_bindings }}'
```

```kotlin
implementation("io.smallrye.reactive:smallrye-mutiny-vertx-core:{{ attributes.versions.vertx_bindings }}")
```

```java
//DEPS io.smallrye.reactive:smallrye-mutiny-vertx-core:{{ attributes.versions.vertx_bindings }}
```

--------------------------------

### Add Mutiny dependency to project

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/getting-mutiny.md

Configures the core Mutiny library dependency for various build tools including Maven, Gradle (Groovy/Kotlin), and JBang. This is the primary step to enable reactive programming features in a Java application.

```xml
<dependency>
    <groupId>io.smallrye.reactive</groupId>
    <artifactId>mutiny</artifactId>
    <version>{{ attributes.versions.mutiny }}</version>
</dependency>
```

```groovy
implementation 'io.smallrye.reactive:mutiny:{{ attributes.versions.mutiny }}'
```

```kotlin
implementation("io.smallrye.reactive:mutiny:{{ attributes.versions.mutiny }}")
```

```java
//DEPS io.smallrye.reactive:mutiny:{{ attributes.versions.mutiny }}
```

--------------------------------

### Mutiny Uni Pipeline Construction in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/hello-mutiny.md

This Java code snippet illustrates the builder API pattern used in Mutiny for constructing Uni pipelines. It shows how appending stages like `onItem().apply()` returns a new Uni instance, and how chaining these operations builds the processing pipeline. It also highlights a common pitfall where intermediate Unis are subscribed to, bypassing subsequent transformations.

```java
import io.smallrye.mutiny.Uni;

public class FirstProgramTest {

    public static void main(String[] args) {
        // Equivalent to the first program
        Uni<String> uni = Uni.createFrom().item("hello")
            .onItem().apply(s -> s + " mutiny")
            .onItem().apply(String::toUpperCase);

        uni.subscribe().with(System.out::println);

        // This program prints only ">> hello"
        Uni<String> uni2 = Uni.createFrom().item("hello");
        uni2.subscribe().with(System.out::println);
    }
}
```

--------------------------------

### Mutiny Rx Equivalents and Usage in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/rx.md

Demonstrates the Mutiny equivalents for RxJava's map, flatMap, and concatMap methods. It shows how to use `onItem().transform()`, `onItem().transformToUniAndMerge()`, `onItem().transformToMultiAndMerge()`, `onItem().transformToUniAndConcatenate()`, and `onItem().transformToMultiAndConcatenate()` in Java.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class RxTest {

    @Test
    public void rx() {
        List<Integer> list = Arrays.asList(1, 2, 3);

        // map equivalent
        Multi.createFrom().iterable(list)
            .onItem().transform(i -> i * 2)
            .subscribe().with(i -> System.out.println("Map: " + i));

        // flatMap equivalent (Uni)
        Multi.createFrom().iterable(list)
            .onItem().transformToUniAndMerge(i -> Uni.createFrom().item(i * 2))
            .subscribe().with(i -> System.out.println("FlatMap Uni: " + i));

        // flatMap equivalent (Multi)
        Multi.createFrom().iterable(list)
            .onItem().transformToMultiAndMerge(i -> Multi.createFrom().items(i, i + 1))
            .subscribe().with(i -> System.out.println("FlatMap Multi: " + i));

        // concatMap equivalent (Uni)
        Multi.createFrom().iterable(list)
            .onItem().transformToUniAndConcatenate(i -> Uni.createFrom().item(i * 2))
            .subscribe().with(i -> System.out.println("ConcatMap Uni: " + i));

        // concatMap equivalent (Multi)
        Multi.createFrom().iterable(list)
            .onItem().transformToMultiAndConcatenate(i -> Multi.createFrom().items(i, i + 1))
            .subscribe().with(i -> System.out.println("ConcatMap Multi: " + i));
    }

    // Example demonstrating the difference between flatMap and concatMap
    @Test
    public void mutiny() {
        AtomicInteger counter = new AtomicInteger(0);

        // flatMap (unordered execution)
        Multi.createFrom().range(1, 4) // Numbers 1, 2, 3
            .onItem().transformToUniAndMerge(i -> Uni.createFrom().item(i).onItem().delayIt().bySeconds(4 - i))
            .subscribe().with(System.out::println);

        // concatMap (ordered execution)
        Multi.createFrom().range(1, 4) // Numbers 1, 2, 3
            .onItem().transformToUniAndConcatenate(i -> Uni.createFrom().item(i).onItem().delayIt().bySeconds(4 - i))
            .subscribe().with(System.out::println);

        // Wait for operations to complete (in a real app, you'd use await().indefinitely() or similar)
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
```

--------------------------------

### Transforming Uni items

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/transforming-items.md

Demonstrates how to transform a single item emitted by a Uni using the onItem().transform() method. This example shows capitalizing a string value.

```java
Uni<String> uni = Uni.createFrom().item("hello");
Uni<String> transformed = uni.onItem().transform(String::toUpperCase);
```

--------------------------------

### Add Mutiny Kotlin Dependency for Maven

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/kotlin.md

This snippet shows how to add the mutiny-kotlin dependency to your Maven project. Ensure you use the correct version matching your Mutiny installation.

```xml
<dependency>
    <groupId>io.smallrye.reactive</groupId>
    <artifactId>mutiny-kotlin</artifactId>
    <version>{{ attributes.versions.mutiny }}</version>
</dependency>
```

--------------------------------

### Create Uni from CompletionStage

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/completion-stage.md

Shows how to wrap a CompletionStage into a Uni. Using a Supplier is recommended to ensure the operation is deferred until subscription and can be re-triggered.

```java
Uni<String> uni = Uni.createFrom().completionStage(() -> getCompletionStage());
```

--------------------------------

### Create Uni<Void>

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Shows how to represent an operation that completes successfully without returning a value by emitting null.

```java
Uni<Void> voidUni = Uni.createFrom().nullItem();
```

--------------------------------

### Create failing and empty Multi streams

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-multi-pipelines.md

Demonstrates how to initialize streams that immediately emit a failure or complete without items.

```java
// Failing
Multi<Object> failed = Multi.createFrom().failure(new IOException("Boom"));

// Empty
Multi<Object> empty = Multi.createFrom().empty();
```

--------------------------------

### Late Subscription with Paused Demand - Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/controlling-demand.md

Delays the upstream subscription until the stream is resumed, in addition to starting paused. This ensures that no items are requested from upstream until the stream is explicitly activated.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.operators.multi.DemandPauser;
import java.util.concurrent.atomic.AtomicReference;

public class PausingDemand {

    public void lateSubscription() {
        AtomicReference<DemandPauser> pauserRef = new AtomicReference<>();

        Multi.createFrom().range(0, 100)
             .pauseDemand(DemandPauser.Builder.create().initiallyPaused().lateSubscription().build())
             .subscribe().with(i -> System.out.println("Received: " + i), 
                               e -> System.err.println("Error: " + e), 
                               () -> System.out.println("Completed"),
                               disposable -> pauserRef.set(disposable.as(DemandPauser.class)));

        // To resume (and trigger subscription):
        // pauserRef.get().resume();
    }
}
```

--------------------------------

### Convert Uni to CompletionStage

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/completion-stage.md

Demonstrates how to subscribe to a Uni and convert it into a CompletionStage. Note that this action triggers the Uni subscription immediately.

```java
CompletionStage<String> cs = uni.subscribeAsCompletionStage();
```

--------------------------------

### Asynchronous side-effects with Mutiny call

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/observing-events.md

Demonstrates the use of the call method to perform asynchronous operations. The first example shows delaying items, while the second illustrates closing a resource asynchronously.

```java
Uni.createFrom().item("hello")
    .call(item -> Uni.createFrom().item(item).onItem().delayIt().by(Duration.ofMillis(100)))
    .subscribe().with(System.out::println);
```

```java
resource.read()
    .call(item -> resource.close())
    .subscribe().with(item -> System.out.println("Received: " + item));
```

--------------------------------

### Accessing Context at Pipeline Source (Builder) in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/context-passing.md

Demonstrates how to access the context when creating a Uni or Multi using builder methods like `Multi.createFrom().context(...)`. This method takes a function that accepts a `Context` and returns a pipeline, enabling context initialization at the source.

```java
Multi.createFrom().context(context -> {
    String value = context.get(String.class);
    return Multi.createFrom().items("a", "b", "c").onItem().apply(i -> i + " " + value);
});
```

--------------------------------

### Starting a Stream in a Paused State - Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/controlling-demand.md

Initializes a stream in a paused state, delaying item flow until explicitly resumed. This is useful for preparing streams whose execution depends on external conditions.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.operators.multi.DemandPauser;
import java.util.concurrent.atomic.AtomicReference;

public class PausingDemand {

    public void initiallyPaused() {
        AtomicReference<DemandPauser> pauserRef = new AtomicReference<>();

        Multi.createFrom().range(0, 100)
             .pauseDemand(DemandPauser.Builder.create().initiallyPaused().build())
             .subscribe().with(i -> System.out.println("Received: " + i), 
                               e -> System.err.println("Error: " + e), 
                               () -> System.out.println("Completed"),
                               disposable -> pauserRef.set(disposable.as(DemandPauser.class)));

        // To resume:
        // pauserRef.get().resume();
    }
}
```

--------------------------------

### Create Multi from Non-Reactive Source using UnicastProcessor (Java)

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/integrate-a-non-reactive-source.md

Demonstrates using UnicastProcessor to create a Multi from a non-reactive source. UnicastProcessor enqueues items and dispatches them to subscribers, allowing integration with sources that lack back-pressure support. The default implementation uses an unbounded queue, but a fixed-size queue can also be configured.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.operators.multi.UnicastProcessor;
import org.junit.jupiter.api.Test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

import static org.assertj.core.api.Assertions.assertThat;

public class UnicastProcessorTest {

    @Test
    public void testUnicastProcessor() {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        UnicastProcessor<Integer> processor = UnicastProcessor.create();

        // Emit items from a non-reactive source (e.g., a loop)
        executor.submit(() -> {
            for (int i = 0; i < 10; i++) {
                processor.onNext(i);
            }
            processor.onComplete();
        });

        // Subscribe to the Multi emitted by the processor
        AtomicInteger count = new AtomicInteger();
        processor.onItem().subscribe().with(item -> {
            System.out.println("Received: " + item);
            assertThat(item).isEqualTo(count.getAndIncrement());
        });

        // Wait for completion (in a real scenario, you'd use proper synchronization)
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        assertThat(count.get()).isEqualTo(10);
        executor.shutdown();
    }

    @Test
    public void testUnicastProcessorWithFixedQueue() {
        // Create a processor with a fixed-size queue (e.g., size 3)
        UnicastProcessor<Integer> processor = UnicastProcessor.create(3);
        AtomicInteger receivedCount = new AtomicInteger();

        // Subscribe first
        processor.onItem().subscribe().with(item -> {
            System.out.println("Received (fixed queue): " + item);
            receivedCount.incrementAndGet();
        });

        // Emit items - the first 3 should be accepted immediately
        for (int i = 0; i < 5; i++) {
            boolean accepted = processor.tryOnNext(i);
            System.out.println("Emitted " + i + ", accepted: " + accepted);
        }

        // At this point, the queue might be full, and subsequent emissions might be rejected
        // In a real application, you'd manage back-pressure or handle rejections.
        // For this test, we'll just check the initial state.
        assertThat(receivedCount.get()).isLessThanOrEqualTo(3);

        // To see more items, you would need to consume from the subscriber to make space
        // For simplicity, we'll just complete it here.
        processor.onComplete();
    }
}
```

--------------------------------

### Filter Multi items with predicates

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Shows techniques for filtering stream items using synchronous predicates or asynchronous conditions. Includes examples for selecting specific ranges, first N items, and distinct values.

```java
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;

Multi<Integer> numbers = Multi.createFrom().range(1, 11);

// Synchronous filtering
List<Integer> evens = numbers
    .select().where(n -> n % 2 == 0)
    .collect().asList()
    .await().indefinitely();

// Async filtering
List<Integer> asyncFiltered = Multi.createFrom().range(1, 11)
    .select().when(n -> Uni.createFrom().item(n > 5))
    .collect().asList()
    .await().indefinitely();

// Select first N items
List<Integer> firstThree = Multi.createFrom().range(1, 100)
    .select().first(3)
    .collect().asList()
    .await().indefinitely();

// Select distinct items
List<Integer> distinct = Multi.createFrom().items(1, 1, 2, 3, 3, 4)
    .select().distinct()
    .collect().asList()
    .await().indefinitely();
```

--------------------------------

### Create Uni from values and suppliers

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Illustrates creating a Uni from a static value or a Supplier. Using a Supplier ensures the value is generated independently for each subscriber.

```java
// From item
Uni<Integer> uni = Uni.createFrom().item(1);

// From supplier
Uni<Integer> uniFromSupplier = Uni.createFrom().item(() -> new Random().nextInt());
```

--------------------------------

### Define a Multi pipeline

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-multi-pipelines.md

Demonstrates how to create a reactive pipeline using Multi operators to transform and process event streams.

```java
Multi.createFrom().items(1, 2, 3, 4, 5)
    .onItem().transform(i -> i * 2)
    .select().where(i -> i > 5)
    .onFailure().recoverWithCompletion();
```

--------------------------------

### Create Uni from CompletionStage and Convert Uni to CompletionStage (Java)

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Shows how to bridge Java's CompletionStage (like CompletableFuture) with Mutiny's Uni. Includes converting a CompletionStage to a Uni and vice-versa, enabling integration with existing asynchronous code.

```java
import io.smallrye.mutiny.Uni;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;

// Convert CompletionStage to Uni
CompletionStage<String> stage = CompletableFuture.supplyAsync(() -> {
    // Simulate async operation
    return "Result from CompletionStage";
});

Uni<String> uni = Uni.createFrom().completionStage(stage);
String result = uni.await().indefinitely();
System.out.println(result); // Output: Result from CompletionStage

// Convert Uni back to CompletionStage
CompletableFuture<String> future = Uni.createFrom().item("Hello")
    .subscribeAsCompletionStage();
System.out.println(future.join()); // Output: Hello
```

--------------------------------

### Concatenate String Streams in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/merging-and-concatenating-streams.md

An example demonstrating the concatenation of streams emitting strings. It highlights that the order of streams provided to the `concat` operator is significant, as it dictates the order in which items will appear in the resulting concatenated stream.

```java
Multi<String> streamA = Multi.createFrom().items("a", "b", "c");
Multi<String> streamB = Multi.createFrom().items("d", "e", "f");

Multi.createBy().concatenating().streams(streamA, streamB)
    .subscribe().with(System.out::println);

// Output:
a
b
c
d
e
f

Multi.createBy().concatenating().streams(streamB, streamA)
    .subscribe().with(System.out::println);

// Output:
d
e
f
a
b
c

```

--------------------------------

### Merge Periodic Events from Multiple Streams in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/merging-and-concatenating-streams.md

An example showcasing the merging of multiple streams that emit periodic events. The output demonstrates the interleaved nature of items emitted by the merged stream as they are received concurrently from the sources.

```java
Multi<Long> stream1 = Multi.createFrom().ticks().every(Duration.ofMillis(100)).select().first(5);
Multi<Long> stream2 = Multi.createFrom().ticks().every(Duration.ofMillis(150)).select().first(4);
Multi<Long> stream3 = Multi.createFrom().ticks().every(Duration.ofMillis(200)).select().first(6);

Multi.createBy().merging().streams(stream1, stream2, stream3)
    .onItem().transform(i -> String.format("Got item: %s", i))
    .subscribe().with(System.out::println);

```

--------------------------------

### Create Multi from items or suppliers

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-multi-pipelines.md

Illustrates creating streams from static collections or dynamic suppliers where the supplier logic executes per subscription.

```java
// From items
Multi<Integer> multi = Multi.createFrom().items(1, 2, 3, 4, 5);

// From supplier
Multi<Integer> multi = Multi.createFrom().deferred(() -> Multi.createFrom().items(1, 2, 3));
```

--------------------------------

### Create failing Uni

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Demonstrates how to create a Uni that immediately emits a failure event, useful for error handling scenarios.

```java
Uni<String> failedUni = Uni.createFrom().failure(new RuntimeException("Boom!"));
```

--------------------------------

### Split Multi Stream using Java Split Operator

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/multi-split.md

Splits a Multi stream into multiple individual Multi streams based on a provided splitter function. Each split stream can be accessed and subscribed to independently using the `get` method.

```java
Multi<String> multi = Multi.createFrom().items("?foo", "!bar", "baz", "!foo", "bar");

Splitter<String, SignalType> splitter = item -> {
    if (item.startsWith("?")) {
        return SignalType.INPUT;
    } else if (item.startsWith("!")) {
        return SignalType.OUTPUT;
    } else {
        return SignalType.OTHER;
    }
};

Split<String, SignalType> split = multi.split(splitter);

Multi<String> input = split.get(SignalType.INPUT);
Multi<String> output = split.get(SignalType.OUTPUT);
Multi<String> other = split.get(SignalType.OTHER);

output.subscribe().with(item -> System.out.println("output - " + item));
input.subscribe().with(item -> System.out.println("input - " + item));
other.subscribe().with(item -> System.out.println("other - " + item));
```

--------------------------------

### Create Multi Streams from Various Sources

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Illustrates multiple ways to instantiate a Multi stream, including from items, iterables, ranges, and empty states, along with subscription patterns.

```java
import io.smallrye.mutiny.Multi;
import java.util.Arrays;
import java.util.List;

Multi<Integer> fromItems = Multi.createFrom().items(1, 2, 3, 4, 5);
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Multi<String> fromIterable = Multi.createFrom().iterable(names);
Multi<Integer> range = Multi.createFrom().range(1, 11);
Multi<String> empty = Multi.createFrom().empty();

Multi.createFrom().items("a", "b", "c")
    .subscribe().with(
        item -> System.out.println("Item: " + item),
        failure -> System.out.println("Failed: " + failure),
        () -> System.out.println("Completed!")
    );
```

--------------------------------

### Build Uni using Kotlin Builders

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/kotlin.md

This demonstrates how to build Mutiny Uni instances using Kotlin's builder pattern. Both regular and coroutine variants are available for creating Unis.

```kotlin
{{ insert('kotlin/guides/UniExt.kt', 'uniBuilder') }}
```

```kotlin
{{ insert('kotlin/guides/Coroutines.kt', 'uniBuilder') }}
```

--------------------------------

### Handle Asynchronous Network Requests with Mutiny

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/index.md

This snippet demonstrates how to process a network request using a Uni pipeline. It includes a timeout mechanism, failure recovery for IO exceptions, and a subscription to handle the final result or error.

```java
Uni<String> request = makeSomeNetworkRequest(params);

request.ifNoItem().after(ofMillis(100))
    .failWith(() -> new TooSlowException("💥"))
    .onFailure(IOException.class).recoverWithItem(fail -> "📦")
    .subscribe().with(
        item -> log("👍 " + item),
         err -> log(err.getMessage())
    );
```

--------------------------------

### Chain Asynchronous Operations with Uni

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Demonstrates how to compose sequential asynchronous operations using flatMap and chain. These methods allow for non-blocking pipelines where each step depends on the result of the previous one.

```java
import io.smallrye.mutiny.Uni;

Uni<String> fetchUser(String userId) {
    return Uni.createFrom().item("User-" + userId);
}

Uni<String> fetchUserOrders(String user) {
    return Uni.createFrom().item("Orders for " + user);
}

Uni<String> pipeline = Uni.createFrom().item("123")
    .flatMap(userId -> fetchUser(userId))
    .flatMap(user -> fetchUserOrders(user));

System.out.println(pipeline.await().indefinitely());

Uni<Void> saveAndNotify = Uni.createFrom().item("data")
    .chain(data -> saveToDatabase(data))
    .chain(() -> sendNotification());
```

--------------------------------

### Subscribe to a Multi stream

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-multi-pipelines.md

Shows how to initiate a stream computation by subscribing and handling item, failure, and completion events. Returns a Cancellable object for lifecycle management.

```java
Cancellable cancellable = multi.subscribe().with(
    item -> System.out.println("Received: " + item),
    failure -> System.err.println("Failed: " + failure),
    () -> System.out.println("Completed")
);
```

--------------------------------

### Create Uni from emitter

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Advanced technique for bridging callback-based APIs into the Mutiny reactive model using an emitter.

```java
Uni<String> uni = Uni.createFrom().emitter(emitter -> {
    doSomethingAsync(result -> emitter.complete(result));
});
```

--------------------------------

### Create Uni from Item, Supplier, Null, or Failure (Java)

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Demonstrates various ways to create a Uni object in Java. Covers creating from a direct item, a supplier function, a null item for void operations, and explicitly creating a failed Uni.

```java
import io.smallrye.mutiny.Uni;
import java.util.concurrent.atomic.AtomicInteger;

// Create from a known value - emits "Hello" immediately on subscription
Uni<String> uniFromItem = Uni.createFrom().item("Hello");
uniFromItem.subscribe().with(
    item -> System.out.println("Received: " + item),   // Output: Received: Hello
    failure -> System.out.println("Failed: " + failure)
);

// Create from a supplier - called for each subscriber
AtomicInteger counter = new AtomicInteger();
Uni<Integer> uniFromSupplier = Uni.createFrom().item(() -> counter.getAndIncrement());
System.out.println(uniFromSupplier.await().indefinitely()); // Output: 0
System.out.println(uniFromSupplier.await().indefinitely()); // Output: 1
System.out.println(uniFromSupplier.await().indefinitely()); // Output: 2

// Create a Uni that emits null (for void operations)
Uni<Void> voidUni = Uni.createFrom().nullItem();

// Create a failed Uni
Uni<String> failedUni = Uni.createFrom().failure(new RuntimeException("Something went wrong"));
```

--------------------------------

### Configure SLF4J Logging for Mutiny (Java)

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/logging.md

Shows how to configure Mutiny's logging behavior to use SLF4J for event reporting. This allows integrating Mutiny's event tracing with existing SLF4J-compatible logging frameworks.

```java
import io.smallrye.mutiny.infrastructure.Infrastructure;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingConfiguration.class);

    public void configureSlf4jLogger() {
        Infrastructure.setDefaultLogger(event -> {
            LOGGER.info("{} | {}", event.getIdentifier(), event.getKind());
        });
    }
}
```

--------------------------------

### Subscribe to a Uni

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Shows how to attach callbacks to a Uni to handle emitted items or failures. The returned Cancellable allows for stopping the operation if necessary.

```java
Cancellable cancellable = uni.subscribe().with(
    item -> System.out.println("Received: " + item),
    failure -> System.err.println("Failed: " + failure)
);
```

--------------------------------

### Create Multi from CompletionStage

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/completion-stage.md

Demonstrates creating a Multi from a CompletionStage. The resulting Multi emits the stage's result as an item or fails if the stage completes exceptionally.

```java
Multi<String> multi = Multi.createFrom().completionStage(() -> getCompletionStage());
```

--------------------------------

### Convert RxJava Completable, Single, Maybe to Mutiny Multi

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/converters.md

Demonstrates how to create a Mutiny Multi from RxJava's Completable, Single, and Maybe types using specific converters. A Completable results in Multi<Void>, Single in Multi<T>, and Maybe in Multi<T> (or completion if empty). Failures are propagated.

```java
Multi<Void> multi = RxJava2CompletionStage.toMulti(completable);
Multi<T> multi = RxJava2CompletionStage.toMulti(single);
Multi<T> multi = RxJava2CompletionStage.toMulti(maybe);
```

--------------------------------

### Buffer Management with Pausing Demand in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/controlling-demand.md

Illustrates buffer management when using the BUFFER strategy with pausing demand in SmallRye Mutiny. The `DemandPauser` allows inspection of buffer size and clearing the buffer while paused.

```java
```java linenums="1"
{{ insert('java/guides/operators/PausingDemandTest.java', 'buffer-management') }}
```
```

--------------------------------

### Convert Reactor types to Mutiny

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/converters.md

Demonstrates converting Project Reactor's Mono and Flux types into Mutiny's Uni and Multi types using Reactive Streams interoperability.

```java
// Converting Flux/Mono to Multi
{{ insert('java/guides/integration/ReactorTest.java', 'reactor-multi-create') }}

// Converting Flux/Mono to Uni
{{ insert('java/guides/integration/ReactorTest.java', 'reactor-uni-create') }}
```

--------------------------------

### Call Async Action with Uni (Java)

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/shortcut-methods.md

The `call` method executes an asynchronous action that returns a Uni. It's a shortcut for `onItem().call(...)`. This is useful for chaining asynchronous operations without altering the original item.

```java
Uni.createFrom().item("data")
    .call(item -> Uni.createFrom().item(item + " processed"))
    .subscribe().with(System.out::println);
```

--------------------------------

### Create Multi using emitters, ticks, and generators

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-multi-pipelines.md

Advanced techniques for creating streams from callback-based APIs, periodic time intervals, or stateful generator functions.

```java
// Emitter
Multi.createFrom().emitter(emitter -> {
    emitter.emit(1);
    emitter.complete();
});

// Ticks
Multi.createFrom().ticks().every(Duration.ofMillis(100));

// Generator
Multi.createBy().generator(() -> 1, (state, emitter) -> {
    int next = state + (state * 2);
    emitter.emit(next);
    return next;
});
```

--------------------------------

### Upgrade and Lock Dependencies with uv

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/README.md

Upgrades all project dependencies to their latest compatible versions and then locks the current versions into the lock file. This ensures reproducible builds.

```shell
uv sync --upgrade
uv lock
```

--------------------------------

### Define a Uni pipeline

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Demonstrates the creation of a simple reactive pipeline using Uni operators. The pipeline remains lazy until a subscriber is attached.

```java
Uni.createFrom().item(1)
    .onItem().transform(i -> i + 1)
    .subscribe().with(item -> System.out.println(item));
```

--------------------------------

### Convert Mutiny types to Reactor

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/converters.md

Demonstrates converting Mutiny's Uni and Multi types into Project Reactor's Mono and Flux types.

```java
// Converting Multi to Flux/Mono
{{ insert('java/guides/integration/ReactorTest.java', 'reactor-create-multi') }}

// Converting Uni to Flux/Mono
{{ insert('java/guides/integration/ReactorTest.java', 'reactor-create-uni') }}

// Using explicit converters
{{ insert('java/guides/integration/ReactorTest.java', 'uni-export') }}
{{ insert('java/guides/integration/ReactorTest.java', 'multi-export') }}
```

--------------------------------

### Create Uni using Emitter for Callback Integration (Java)

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Illustrates using Mutiny's Emitter to integrate with traditional callback-based asynchronous APIs. The emitter allows manual completion or failure signaling from a callback context into the reactive Uni stream.

```java
import io.smallrye.mutiny.Uni;

// Using an emitter for callback-based integration
Uni<String> uniFromEmitter = Uni.createFrom().emitter(emitter -> {
    // Simulate an async callback-based API
    new Thread(() -> {
        try {
            Thread.sleep(100);
            emitter.complete("Async result");
        } catch (Exception e) {
            emitter.fail(e);
        }
    }).start();
});

uniFromEmitter.subscribe().with(
    item -> System.out.println("Got: " + item),  // Output: Got: Async result
    failure -> System.out.println("Error: " + failure)
);
```

--------------------------------

### Create Uni from CompletionStage

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/tutorials/creating-uni-pipelines.md

Integrates existing Java CompletionStage or CompletableFuture objects into the Mutiny ecosystem.

```java
CompletionStage<String> cs = CompletableFuture.completedFuture("Hello");
Uni<String> uni = Uni.createFrom().completionStage(cs);
```

--------------------------------

### Prepend seed data for replay

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/replaying-multis.md

Allows providing an initial set of items via an Iterable that subscribers receive before the upstream source begins emitting.

```java
Multi<Integer> upstream = Multi.createFrom().range(0, 10)
    .broadcast().toAllSubscribers().replay().withSeed(List.of(-10, -5, -1));

List<Integer> items = upstream.subscribe().asStream().collect(Collectors.toList());
```

--------------------------------

### Test Uni and Multi Pipelines with Mutiny

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/testing.md

Demonstrates how to use Mutiny's test subscribers to assert outcomes for Uni and Multi reactive types. It covers testing successful emissions as well as verifying expected failure scenarios.

```java
// Testing a Uni
{{ insert('java/guides/TestSubscribersTest.java', 'uni') }}
```

```java
// Testing a Multi
{{ insert('java/guides/TestSubscribersTest.java', 'multi') }}
```

```java
// Testing failures
{{ insert('java/guides/TestSubscribersTest.java', 'failing') }}
```

--------------------------------

### Recover from failures with fallback items or streams in Mutiny

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Demonstrates various recovery strategies including providing default items, computing fallbacks from exceptions, switching to backup Uni streams, and swallowing errors to complete streams gracefully.

```java
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.Multi;

// Recover with a fallback item
Uni<String> uniWithFallback = Uni.createFrom()
    .failure(new RuntimeException("Connection failed"))
    .onFailure().recoverWithItem("Default value");

// Recover with a computed fallback
Uni<String> computed = Uni.createFrom()
    .failure(new RuntimeException("Error"))
    .onFailure().recoverWithItem(failure -> "Recovered from: " + failure.getMessage());

// Recover with another Uni
Uni<String> primaryService = Uni.createFrom().failure(new RuntimeException("Primary down"));
Uni<String> backupService = Uni.createFrom().item("Backup result");
Uni<String> resilient = primaryService.onFailure().recoverWithUni(backupService);

// Multi: recover with completion (swallow the error)
List<Integer> items = Multi.createFrom().items(1, 2, 3)
    .onItem().transformToUniAndMerge(i -> {
        if (i == 2) return Uni.createFrom().failure(new RuntimeException("Error"));
        return Uni.createFrom().item(i);
    })
    .onFailure().recoverWithCompletion()
    .collect().asList()
    .await().indefinitely();
```

--------------------------------

### Select first items in Mutiny

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/take-skip-items.md

Demonstrates selecting the first n items or the first item from a Multi stream using select().first().

```java
{{ insert('java/guides/operators/SelectAndSkipTest.java', 'take-first') }}
```

--------------------------------

### Handling Events with Mutiny API in Java

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/reference/what-makes-mutiny-different.md

Demonstrates how to handle different event types in SmallRye Mutiny using the 'on' associated methods. The 'invoke' method is commonly used to process events, with other methods like 'recover' and 'continueWith' available for specific event groups.

```java
public class EventsTest {

    @Test
    public void testOnEvent() {
        MutableUni<String> uni = Uni.createFrom().item("hello");

        uni.onItem().invoke(s -> {
            System.out.println("Received: " + s);
        }).subscribe().with(s -> {
            System.out.println("Subscribed: " + s);
        });
    }

    @Test
    public void testOnFailure() {
        MutableUni<String> uni = Uni.createFrom().failure(new Exception("test"));

        uni.onFailure().recover().with(e -> {
            System.out.println("Recovered from exception: " + e.getMessage());
            return Uni.createFrom().item("recovered");
        }).subscribe().with(s -> {
            System.out.println("Subscribed: " + s);
        });
    }

    @Test
    public void testOnCompletion() {
        MutableUni<String> uni = Uni.createFrom().item("hello");

        uni.onCompletion().continueWith(() -> {
            System.out.println("Completed!");
            return Uni.createFrom().nullItem();
        }).subscribe().with(s -> {
            System.out.println("Subscribed: " + s);
        });
    }
}
```

--------------------------------

### Combine multiple Unis using Tuples and combineWith

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/guides/combining-items.md

Demonstrates how to execute multiple asynchronous Uni operations concurrently and aggregate their results. It covers using Tuple-based combination for up to 9 items and the combineWith method for custom aggregation logic.

```java
Uni<String> uniA = Uni.createFrom().item("hello");
Uni<Integer> uniB = Uni.createFrom().item(1);

// Combine using Tuples
Uni<Tuple2<String, Integer>> combined = Uni.combine().all().unis(uniA, uniB).asTuple();

// Combine with custom function
Uni<String> combinedWith = Uni.combine().all().unis(uniA, uniB)
    .combinedWith((a, b) -> a + "-" + b);
```

--------------------------------

### Combine Multi Streams by Index (Java)

Source: https://context7.com/smallrye/smallrye-mutiny/llms.txt

Explains how to combine items from multiple `Multi` streams based on their emission index. It pairs the first item from each stream, then the second, and so on, applying a transformation function to each pair. This is useful for correlating data emitted at the same position across different streams.

```java
import io.smallrye.mutiny.Multi;
import java.util.List;

Multi<Integer> numbers = Multi.createFrom().items(1, 2, 3);
Multi<String> letters = Multi.createFrom().items("A", "B", "C");

// Combine by index into tuples
List<String> combined = Multi.createBy().combining()
    .streams(numbers, letters)
    .using((n, l) -> n + "-" + l)
    .collect().asList()
    .await().indefinitely();
System.out.println(combined); // Output: [1-A, 2-B, 3-C]
```

--------------------------------

### Creating reactive types from in-memory data

Source: https://github.com/smallrye/smallrye-mutiny/blob/main/documentation/docs/reference/going-reactive-a-few-pitfalls.md

Illustrates the creation of Uni and Multi from static in-memory data, which is useful for testing but often indicates a lack of actual asynchronous I/O in production code.

```java
Uni<String> uni = Uni.createFrom().item("hello");
Multi<Integer> multi = Multi.createFrom().items(1, 2, 3);
```