*/
  public static <V1 extends @Nullable Object, V2 extends @Nullable Object>
      Combiner2<V1, V2> whenAllSucceed(ClosingFuture<V1> future1, ClosingFuture<V2> future2) {
    return new Combiner2<>(future1, future2);
  }

  /**
   * Starts specifying how to combine three {@link ClosingFuture}s into a single pipeline, assuming

import com.google.common.util.concurrent.ClosingFuture.Combiner;
import com.google.common.util.concurrent.ClosingFuture.Combiner.AsyncCombiningCallable;
import com.google.common.util.concurrent.ClosingFuture.Combiner.CombiningCallable;
import com.google.common.util.concurrent.ClosingFuture.Combiner2.AsyncClosingFunction2;
import com.google.common.util.concurrent.ClosingFuture.Combiner2.ClosingFunction2;

///

## Combiner les informations { #combining-information }

Vous pouvez également combiner des informations de réponse provenant de plusieurs endroits, y compris les paramètres `response_model`, `status_code` et `responses`.

    Là encore, vous pouvez combiner `dataclasses` avec des annotations de type standard.

8. Notez que cette *fonction de chemin d'accès* utilise un `def` classique au lieu de `async def`.

    Comme toujours, avec FastAPI vous pouvez combiner `def` et `async def` selon vos besoins.

    /**
     * Reduces a map of boolean flag properties to a single provider by applying the given
     * combiner function to the corresponding values of the properties that are true.
     *
     * @param flags The map of boolean properties mapped to their values.
     * @param combiner The function to combine the values of the true properties.
     *

        Callable<C> combiner, Executor executor) {
      return new CombinedFuture<>(futures, allMustSucceed, executor, combiner);
    }

    /**
     * Creates the {@link ListenableFuture} which will return the result of running {@code combiner}
     * when all Futures complete. {@code combiner} will run using {@code executor}.
     *

        A accum = collector.supplier().get();
        for (T input : inputs) {
          A newAccum = collector.supplier().get();
          collector.accumulator().accept(newAccum, input);
          accum = collector.combiner().apply(accum, newAccum);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators right-to-left. */
    MERGE_RIGHT_ASSOCIATIVE {
      @Override

        A accum = collector.supplier().get();
        for (T input : inputs) {
          A newAccum = collector.supplier().get();
          collector.accumulator().accept(newAccum, input);
          accum = collector.combiner().apply(accum, newAccum);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators right-to-left. */
    MERGE_RIGHT_ASSOCIATIVE {
      @Override

      }
    }

    /*
     * While the current implementation returns `this`, that's not something we mean to guarantee.
     * Anyway, the purpose of this method is to implement a BinaryOperator combiner for a Collector,
     * so its return value will get used naturally.
     */
    @SuppressWarnings("CanIgnoreReturnValueSuggester")
    ImmutableTableCollectorState<R, C, V> combine(

      }
    }

    /*
     * While the current implementation returns `this`, that's not something we mean to guarantee.
     * Anyway, the purpose of this method is to implement a BinaryOperator combiner for a Collector,
     * so its return value will get used naturally.
     */
    @SuppressWarnings("CanIgnoreReturnValueSuggester")
    ImmutableTableCollectorState<R, C, V> combine(