En option ou en option en Java

J'ai travaillé avec le nouveau type facultatif dans Java 8 , et j'ai rencontré ce qui semble être une opération courante qui n'est pas prise en charge fonctionnellement: un "orElseOptional"

Considérez le modèle suivant:

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);
}

Il existe de nombreuses formes de ce modèle, mais cela revient à vouloir un "orElse" sur un optionnel qui prend une fonction produisant un nouveau optionnel, appelé uniquement si l'actuel n'existe pas.

Son implémentation ressemblerait à ceci:

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

Je suis curieux de savoir s'il y a une raison pour laquelle une telle méthode n'existe pas, si j'utilise simplement Optionnel de manière non intentionnelle, et quelles autres façons les gens ont trouvées pour traiter ce cas.

Je dois dire que je pense que les solutions impliquant des classes / méthodes utilitaires personnalisées ne sont pas élégantes car les personnes travaillant avec mon code ne sauront pas nécessairement qu'elles existent.

De plus, si quelqu'un le sait, une telle méthode sera-t-elle incluse dans JDK 9, et où puis-je proposer une telle méthode? Cela me semble être une omission assez flagrante de l'API.

Cela fait partie du JDK 9 sous la forme de or, qui prend un Supplier<Optional<T>>. Votre exemple serait alors:

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

Pour plus de détails, consultez le Javadoc ou ce post que j'ai écrit.

L'approche «essayer les services» la plus propre étant donné l'API actuelle serait:

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();

L'aspect important n'est pas la chaîne (constante) d'opérations que vous devez écrire une seule fois mais la facilité avec laquelle il est d'ajouter un autre service (ou de modifier la liste des services est générale). Ici, ajouter ou supprimer un single ()->serviceX(args)suffit.

En raison de l'évaluation paresseuse des flux, aucun service ne sera appelé si un service précédent a renvoyé une valeur non vide Optional.

Ce n'est pas joli, mais cela fonctionnera:

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)est un modèle assez pratique à utiliser avec Optional. Cela signifie "Si cela Optionalcontient de la valeur v, donnez-moi func(v), sinon donnez-moi sup.get()".

Dans ce cas, nous appelons serviceA(args)et obtenons un fichier Optional<Result>. Si cela Optionalcontient une valeur v, nous voulons obtenir Optional.of(v), mais si elle est vide, nous voulons obtenir serviceB(args). Rincer-répéter avec plus d'alternatives.

D'autres utilisations de ce modèle sont

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

C'est peut-être ce que vous recherchez: obtenez de la valeur à partir de l'un ou l'autre facultatif

Sinon, vous voudrez peut-être jeter un coup d'œil à Optional.orElseGet. Voici un exemple de ce que je pense que vous recherchez:

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

En supposant que vous soyez toujours sur JDK8, il existe plusieurs options.

Option n ° 1: créez votre propre méthode d'aide

Par exemple:

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);
    }
}

Pour que vous puissiez faire:

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

Option 2: utiliser une bibliothèque

Par exemple, l'option facultative de google guava prend en charge une or()opération correcte (tout comme JDK9), par exemple:

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

(Où chacun des services revient com.google.common.base.Optional, plutôt que java.util.Optional).

Cela ressemble à un bon ajustement pour la correspondance de modèles et une interface Option plus traditionnelle avec des implémentations Some et None (telles que celles de Javaslang , FunctionalJava ) ou une implémentation paresseuse Maybe dans cyclops-react Je suis l'auteur de cette bibliothèque.

Avec cyclops-react, vous pouvez également utiliser la correspondance de motifs structurels sur les types JDK. Pour Optionnel, vous pouvez faire correspondre les cas présents et absents via le modèle de visiteur . ça ressemblerait à quelque chose comme ça -

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

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