Maybe

A monadic type representing a result of some computation. It can be a Just or a Nothing. Just contains the computed value, Nothing indicates that result for the computations is unavailable (no other information is passed).

If information about the cause of computation failure is needed please check Try instead.

Maybe can be compared to Java's Optional, Scala's Option or Haskell's Maybe type.

Java doesn't have means to define sealed class hierarchies, due to this limitation Maybe is an abstract class with a protected constructor. This simulates a sealed hierarchy as Just and Nothing are the only possible subclasses.

To create a Just:

Maybe<String> mj = Maybe.just("some value");
  

To create a Nothing:

Maybe<Integer> mn = Maybe.nothing();
  

Let's look at a usage example. There is a function that returns a Maybe String, we want to process the probable String by changing it to a number (it's size) and then checking if the value is larger then a certain threshold.

// we have a partial function that returns a Maybe result
  final Maybe<String> result = somePartialFunction(args);
 
  // we then want to process the result Maybe
  final Maybe<Integer> processed =
      // first we change the string to it's length
      result.map(string -> string.length())
        // then we check if the size is above the desired threshold
        .filter(size -> size > THRESHOLD);
 
 
   // At this stage Maybe can be Just Integer or Nothing. It's possible to react
   // to it in two ways:
   if (processed.isJust()) {
       // do something if the value exist
   }
 
   if (processed.isNothing()) {
       // do something if the value does not exist
   }
 
 
   // We can also do the same conditions in chain rather then explicit if statement:
   processed
       .ifJust(value -> {
           // do something if the value exist
       })
       .ifNothing(nothing -> {
           // do something if the value does not exist
       });
  
  

Note: Implementation of this class was made to be extremely familiar for anyone that is used to Java Optional, Scala Option or Vavr.io Option.

Types

Constructors

Functions

Inheritors