Opcional ouElse Opcional em Java

Eu tenho trabalhado com o novo tipo opcional no Java 8 e me deparei com o que parece ser uma operação comum sem suporte funcional: um "ouElseOptional"

Considere o seguinte padrão:

Optional<Result> resultFromServiceA = serviceA(args);
if (resultFromServiceA.isPresent) return result;
else {
    Optional<Result> resultFromServiceB = serviceB(args);
    if (resultFromServiceB.isPresent) return resultFromServiceB;
    else return serviceC(args);
}

Existem muitas formas desse padrão, mas tudo se resume a querer um "orElse" em um opcional que assume uma função que produz um novo opcional, chamado apenas se o atual não existir.

Sua implementação ficaria assim:

public Optional<T> orElse(Supplier<Optional<? extends T>> otherSupplier) {
    return value != null ? this : other.get();
}

Estou curioso para saber se existe um motivo para que esse método não exista, se estou apenas usando o Opcional de maneira não intencional e de que outras maneiras as pessoas inventaram para lidar com esse caso.

Devo dizer que acho que as soluções que envolvem classes / métodos de utilitários personalizados não são elegantes porque as pessoas que trabalham com meu código não necessariamente sabem que elas existem.

Além disso, se alguém souber, esse método será incluído no JDK 9, e onde devo propor esse método? Isso parece uma omissão bastante flagrante para a API para mim.

Isso faz parte do JDK 9 na forma de or, que leva a Supplier<Optional<T>>. Seu exemplo seria então:

return serviceA(args)
    .or(() -> serviceB(args))
    .or(() -> serviceC(args));

Para detalhes, consulte o Javadoc ou este post que escrevi.

A abordagem mais limpa de "experimentar serviços", dada a API atual, seria:

Optional<Result> o = Stream.<Supplier<Optional<Result>>>of(
    ()->serviceA(args), 
    ()->serviceB(args), 
    ()->serviceC(args), 
    ()->serviceD(args))
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();

O aspecto importante não é a cadeia (constante) de operações que você precisa escrever uma vez, mas a facilidade de adicionar outro serviço (ou modificar a lista de serviços é geral). Aqui, adicionando ou removendo um único()->serviceX(args) é suficiente.

Devido à avaliação lenta dos fluxos, nenhum serviço será chamado se um serviço anterior retornar um não vazio Optional.

Não é bonito, mas isso funcionará:

return serviceA(args)
  .map(Optional::of).orElseGet(() -> serviceB(args))
  .map(Optional::of).orElseGet(() -> serviceC(args))
  .map(Optional::of).orElseGet(() -> serviceD(args));

.map(func).orElseGet(sup)é um padrão bastante útil para uso com Optional. Significa "Se isso Optionalcontém valor v, me dê func(v), caso contrário, me dêsup.get() ".

Nesse caso, chamamos serviceA(args)e obtemos um Optional<Result>. Se isso Optionalcontém valor v, queremos obter Optional.of(v), mas se estiver vazio, queremos obterserviceB(args) . Repita a lavagem com mais alternativas.

Outros usos desse padrão são

• .map(Stream::of).orElseGet(Stream::empty)
• .map(Collections::singleton).orElseGet(Collections::emptySet)

Talvez seja isso que você procura: obtenha valor de um opcional ou de outro

Caso contrário, você pode querer dar uma olhada Optional.orElseGet. Aqui está um exemplo do que eu acho que você procura:

result = Optional.ofNullable(serviceA().orElseGet(
                                 () -> serviceB().orElseGet(
                                     () -> serviceC().orElse(null))));

Supondo que você ainda esteja no JDK8, existem várias opções.

Opção 1: crie seu próprio método auxiliar

Por exemplo:

public class Optionals {
    static <T> Optional<T> or(Supplier<Optional<T>>... optionals) {
        return Arrays.stream(optionals)
                .map(Supplier::get)
                .filter(Optional::isPresent)
                .findFirst()
                .orElseGet(Optional::empty);
    }
}

Para que você possa fazer:

return Optionals.or(
   ()-> serviceA(args),
   ()-> serviceB(args),
   ()-> serviceC(args),
   ()-> serviceD(args)
);

Opção 2: use uma biblioteca

Por exemplo, o opcional do google guava suporta uma or()operação adequada (como o JDK9), por exemplo:

return serviceA(args)
  .or(() -> serviceB(args))
  .or(() -> serviceC(args))
  .or(() -> serviceD(args));

(Onde cada um dos serviços retorna com.google.common.base.Optional, em vez de java.util.Optional).

Este é parece um bom ajuste para correspondência de padrão e uma interface opção mais tradicional com alguns e nenhum implementações (tais como aqueles em Javaslang , FunctionalJava ) ou um preguiçoso Talvez implementação em cyclops-reagir .Eu estou o autor desta biblioteca.

Com o cyclops-react, você também pode usar a correspondência de padrões estruturais nos tipos JDK. Para Opcional, você pode corresponder nos casos presentes e ausentes por meio do padrão de visitante . seria algo parecido com isto -

  import static com.aol.cyclops.Matchables.optional;

  optional(serviceA(args)).visit(some -> some , 
                                 () -> optional(serviceB(args)).visit(some -> some,
                                                                      () -> serviceC(args)));