/// check | A inspiré **FastAPI** à

Être un micro-framework. Il est donc facile de combiner les outils et les pièces nécessaires.

Proposer un système de routage simple et facile à utiliser.

///

### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>

          .doubleValue();

  /**
   * Returns a stream of a million primitive doubles. The stream is parallel, which should cause
   * {@code collect} calls to run in multithreaded mode, so testing the combiner as well as the
   * supplier and accumulator.
   */
  static DoubleStream megaPrimitiveDoubleStream() {
    return DoubleStream.iterate(0.0, x -> x + 1.0).limit(MEGA_STREAM_COUNT).parallel();
  }

     * 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")
    Builder<K, V> combine(ImmutableSortedMap.Builder<K, V> other) {
      ensureCapacity(size + other.size);

// qProp contains analysis info about an SQL term.
type qProp struct {
	isAggregation, isRowFunc bool

	err error
}

// `combine` combines a pair of `qProp`s, so that errors are
// propagated correctly, and checks that an aggregation is not being
// combined with a row-function term.
func (p *qProp) combine(q qProp) {
	switch {
	case p.err != nil:
		// Do nothing
	case q.err != nil:
		p.err = q.err
	default:

        }

        @Test
        @DisplayName("Should combine referral data")
        void testCombine() {
            DfsReferralDataInternal combined = mock(DfsReferralDataInternal.class);

            // Test with mock
            when(mockReferralData.combine(mockDfsReferralData)).thenReturn(combined);
            DfsReferralDataInternal result = mockReferralData.combine(mockDfsReferralData);
            assertSame(combined, result);

 *
 * <p>The merger supports two main types of combinations:</p>
 * <ul>
 *   <li>Children combination: Controls how child elements are combined</li>
 *   <li>Self combination: Controls how the element itself is combined</li>
 * </ul>
 *
 * <p>Children combination modes (specified by {@code combine.children} attribute):</p>
 * <ul>
 *   <li>{@code merge} (default): Merges elements with matching names</li>

            second.setDomain("DOMAIN");

            // Combine
            DfsReferralDataInternal combined = first.combine(second);

            assertNotNull(combined);
            assertEquals("server2", combined.getServer());
            assertEquals("share2", combined.getShare());
            assertEquals("path2", combined.getPath());
            assertEquals("DOMAIN", combined.getDomain());

		},
		cli.BoolFlag{
			Usage: "combine inline data",
			Name:  "combine",
		},
		cli.BoolFlag{
			Usage: "combine inline data across versions when size matches",
			Name:  "xver",
		},
	}

	app.Action = func(c *cli.Context) error {
		ndjson := c.Bool("ndjson")
		if c.Bool("data") && c.Bool("combine") {
			return errors.New("cannot combine --data and --combine")
		}
		// file / version / file

It will all be combined and included in your OpenAPI, and shown in the API docs:

<img src="/img/tutorial/additional-responses/image01.png">

## Combine predefined responses and custom ones { #combine-predefined-responses-and-custom-ones }

You might want to have some predefined responses that apply to many *path operations*, but you want to combine them with custom responses needed by each *path operation*.

        this.scopes = new HashSet<>();

        addScopes(scopes);
    }

    /**
     * Creates a new filter that combines the specified filters.
     *
     * @param filters The filters to combine, may be {@code null}.
     */
    public CumulativeScopeArtifactFilter(CumulativeScopeArtifactFilter... filters) {
        this.scopes = new HashSet<>();