org.organicdesign.fp.either

Class OneOf2<A,B>

java.lang.Object

org.organicdesign.fp.either.OneOf2<A,B>

public class OneOf2<A,B>
extends Object

This approximates union of two types for Java. It works, but it's a little experimental in the sense of "Is this the best way to do it?" and, "How good of an idea is this in general?" Java has specifically avoided union types in favor of defining a super-type and making those other two types extend the new parent. But sometimes you don't have control of the two types to make them inherit from a common ancestor. You could write a wrapper class, but that can be really complicated. Even if you can add new ancestor to types you control, doing so could involve a complex code rewrite of multiple classes, when all you need is to pass one little parameter to one function... People typically solve this dilemma with an Either<L,R> class with Left<L> and Right<R> sub-classes. In a language with type aliases that's ideal, but the closest Java comes to aliases is sub-classing and for that you need a single class to inherit from. On the bright side, this gives you the chance to add descriptive method names at the same time. When Java users say "Pattern Matching" they mean Regular Expressions so the method that behaves like what Scala and ML would call Pattern Matching is called "typeMatch" instead. The safest way to use OneOf classes is to always call typeMatch() because it forces you to think about how to handle each type you could possibly receive. Usage:

union.typeMatch(fst -> fst.doOneThing(),
                sec -> sec.doSomethingElse());
 

Sometimes it's a programming error to pass one type or another and you may want to throw an exception.

union.typeMatch(fst -> fst.doOneThing(),
                sec -> { throw new IllegalStateException("Asked for a 2nd; only had a 1st."); });
 

As a shortcut, you can call (using method references) union::throw1 or union::throw2

union.typeMatch(fst -> fst.doOneThing(),
                union::throw2);
 

For the shortest syntax and best names, define your own subclass. This is no where near as elegant as sub-classing Tuples.

public class A_Or_B extends OneOf2<ClassA,ClassB> {
    // Constructor
    A_Or_B(ClassA cre, ClassB rev, int s) { super(cre, rev, s); }

    // Static factory method for first type
    public static A_Or_B fst(ClassA cre) {
        return new A_Or_B(cre, null, 1);
    }

    // Static factory method for second type
    public static A_Or_B sec(ClassB rev) {
        return new A_Or_B(null, rev, 2);
    }

    // Return first or throw exception
    public ClassA fst() {
        return typeMatch(cre -> cre,
                         super::throw2);
    }

    // Return second or throw exception
    public ClassB sec() {
        return typeMatch(super::throw1,
                         rev -> rev);
    }
}
 

Now you use descriptive and extremely brief syntax:

union.fst().doOneThing();
 

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	OneOf2(A a, B b, int s)

Method Summary

Modifier and Type	Method and Description
boolean	equals(Object other)
int	hashCode()
<R> R	throw1(A a)
<R> R	throw2(B b)
<R> R	typeMatch(Function1<A,R> fa, Function1<B,R> fb)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

OneOf2

protected OneOf2(A a,
                 B b,
                 int s)

Method Detail

typeMatch

public <R> R typeMatch(Function1<A,R> fa,
                       Function1<B,R> fb)

throw1

public <R> R throw1(A a)

throw2

public <R> R throw2(B b)

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object other)

Overrides:

equals in class Object