¿Es un antipatrón usar peek () para modificar un elemento de flujo?

Supongamos que tengo una secuencia de Cosas y quiero "enriquecerlas" a mitad de la secuencia, puedo usar peek()para hacer esto, por ejemplo:

streamOfThings.peek(this::thingMutator).forEach(this::someConsumer);

Suponga que mutar las cosas en este punto del código es un comportamiento correcto; por ejemplo, el thingMutatormétodo puede establecer el campo "lastProcessed" en la hora actual.

Sin embargo, peek()en la mayoría de los contextos significa "mirar, pero no tocar".

¿Está utilizando peek()para mutar elementos de la corriente un antipatrón o mal aconsejado?

Editar:

El enfoque alternativo, más convencional, sería convertir al consumidor:

private void thingMutator(Thing thing) {
    thing.setLastProcessed(System.currentTimeMillis());
}

a una función que devuelve el parámetro:

private Thing thingMutator(Thing thing) {
    thing.setLastProcessed(currentTimeMillis());
    return thing;
}

y usar map()en su lugar:

stream.map(this::thingMutator)...

Pero eso introduce código superficial (the return) y no estoy convencido de que sea más claro, porque sabes que peek()devuelve el mismo objeto, pero con map()ni siquiera es claro de un vistazo que es la misma clase de objeto.

Además, con peek()usted puede tener una lambda que muta, pero con map()usted tiene que construir un choque de trenes. Comparar:

stream.peek(t -> t.setLastProcessed(currentTimeMillis())).forEach(...)
stream.map(t -> {t.setLastProcessed(currentTimeMillis()); return t;}).forEach(...)

Creo que la peek()versión es más clara y la lambda está claramente mutando, por lo que no hay ningún efecto secundario "misterioso". Del mismo modo, si se usa una referencia de método y el nombre del método implica claramente una mutación, eso también es claro y obvio.

En una nota personal, no evito usar peek()para mutar, me parece muy conveniente.

Tienes razón, "mirar" en el sentido inglés de la palabra significa "mirar, pero no tocar".

Sin embargo los JavaDoc estados:

ojeada

Stream peek (Acción del consumidor)

Devuelve una secuencia que consta de los elementos de esta secuencia, además de realizar la acción proporcionada en cada elemento a medida que los elementos se consumen de la secuencia resultante.

Palabras clave: "realizando ... acción" y "consumido". El JavaDoc tiene muy claro que debemos esperar peektener la capacidad de modificar la secuencia.

Sin embargo, JavaDoc también establece:

Nota de API:

Este método existe principalmente para admitir la depuración, donde desea ver los elementos a medida que fluyen más allá de cierto punto en una tubería

Esto indica que está destinado más a la observación, por ejemplo, elementos de registro en la secuencia.

Lo que deduzco de todo esto es que podemos realizar acciones utilizando los elementos en la secuencia, pero debemos evitar la mutación de elementos en la secuencia. Por ejemplo, siga adelante y llame a métodos en los objetos, pero trate de evitar las operaciones de mutación en ellos.

Como mínimo, agregaría un breve comentario a su código a lo largo de estas líneas:

// Note: this peek() call will modify the Things in the stream.
streamOfThings.peek(this::thingMutator).forEach(this::someConsumer);

Las opiniones difieren sobre la utilidad de tales comentarios, pero usaría ese comentario en este caso.

Podría malinterpretarse fácilmente, por lo que evitaría usarlo así. Probablemente la mejor opción es utilizar una función lambda para fusionar las dos acciones que necesita en la llamada forEach. También puede considerar devolver un nuevo objeto en lugar de mutar el existente; puede ser un poco menos eficiente, pero es probable que genere un código más legible y reduzca el potencial de usar accidentalmente la lista modificada para otra operación que debería Han recibido el original.

La nota de API nos dice que el método se ha agregado principalmente para acciones como depuración / registro / estadísticas de disparo, etc.

@apiNote Este método existe principalmente para admitir la depuración, donde desea * ver los elementos a medida que fluyen más allá de cierto punto en una tubería: *

       {@código
     * Stream.of ("uno", "dos", "tres", "cuatro")
     * .filter (e -> e.length ()> 3)
     * .peek (e -> System.out.println ("Valor filtrado:" + e))
     * .map (String :: toUpperCase)
     * .peek (e -> System.out.println ("Valor asignado:" + e))
     * .collect (Collectors.toList ());
     *}