@Override
      Object operate(Stream<?> stream) {
        return stream.reduce((a, b) -> b);
      }
    },
    REDUCE_LAST_PARALLEL {
      @Override
      Object operate(Stream<?> stream) {
        return stream.parallel().reduce((a, b) -> b);
      }
    };

    abstract Object operate(Stream<?> stream);
  }

  @Param private Operation operation;

  Collection<Object> collection;

  @BeforeExperiment

    /**
     * Get configuration to pass to the goals.
     *
     * @return Object
     */
    public Object getConfiguration() {
        return this.configuration;
    } // -- Object getConfiguration()

    /**
     * Method getGoals.
     *
     * @return List
     */
    public java.util.List<String> getGoals() {
        if (this.goals == null) {

```

</div>

/// note | Nota

El comando `uvicorn main:app` se refiere a:

* `main`: el archivo `main.py` (el "módulo" de Python).
* `app`: el objeto creado dentro de `main.py` con la línea `app = FastAPI()`.
* `--reload`: hace que el servidor se reinicie cada vez que cambia el código. Úsalo únicamente para desarrollo.

///

<span style="color: green;">INFO</span>:     Application startup complete.
```

</div>

/// note | "Nota"

O comando `uvicorn main:app` se refere a:

* `main`: o arquivo `main.py` (o "módulo" Python).
* `app`: o objeto criado no arquivo `main.py` com a linha `app = FastAPI()`.
* `--reload`: faz o servidor reiniciar após mudanças de código. Use apenas para desenvolvimento.

///

Na saída, temos:

```hl_lines="4"

E então você pode definir o `status_code` neste objeto de retorno temporal.

```Python hl_lines="1  9  12"
{!../../docs_src/response_change_status_code/tutorial001.py!}
```

E então você pode retornar qualquer objeto que você precise, como você faria normalmente (um `dict`, um modelo de banco de dados, etc.).

E se você declarar um `response_model`, ele ainda será utilizado para filtrar e converter o objeto que você retornou.

  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment
  void setUp() {
    array = new Object[size];
    arrayList = Lists.newArrayListWithCapacity(size);
    linkedList = Lists.newLinkedList();

    for (int i = 0; i < size; i++) {
      Object value = new Object();
      array[i] = value;
      arrayList.add(value);

    private final Object root;

    /**
     * Construct a new value source, using the supplied object as the root from
     * which to start, and using expressions split at the dot ('.') to navigate
     * the object graph beneath this root.
     * @param root the root of the graph.
     */
    public ObjectBasedValueSource(Object root) {
        super(true);
        this.root = root;
    }

      return (K[]) new Object[length];
    }

    @SuppressWarnings("unchecked")
    @Override
    public V[] createValueArray(int length) {
      return (V[]) new Object[length];
    }

    @Override
    public TestSubjectGenerator<?> getInnerGenerator() {
      return generator;
    }
  }

  public static class InverseBiMapGenerator<K extends @Nullable Object, V extends @Nullable Object>

E então você pode definir cookies nesse objeto de resposta *temporário*.

```Python hl_lines="1  8-9"
{!../../docs_src/response_cookies/tutorial002.py!}
```

Em seguida, você pode retornar qualquer objeto que precise, como normalmente faria (um `dict`, um modelo de banco de dados, etc).

E se você declarou um `response_model`, ele ainda será usado para filtrar e converter o objeto que você retornou.

Então você pode definir os cabeçalhos nesse objeto de resposta *temporário*.

```Python hl_lines="1  7-8"
{!../../docs_src/response_headers/tutorial002.py!}
```

Em seguida você pode retornar qualquer objeto que precisar, da maneira que faria normalmente (um `dict`, um modelo de banco de dados, etc.).

Se você declarou um `response_model`, ele ainda será utilizado para filtrar e converter o objeto que você retornou.