Best way to create a Union type for ImmutablePairs in Java

In a Java program that I need to enhance I have a data structure

List<ImmutablePair<Integer, String>> params;

using ImmutablePair from org.apache.commons.lang3.tuple.

Going forward the String parameter needs to be able to hold either a String or a Double. For this I would like to create something like a union or Sum type of the two basic types.

How do I define this in Java for a list of ImmutablePairs?

I'm not clear what your question has to do with ImmutablePair.

I would just do something like this:

import java.util.function.Function;
public interface StringOrDouble {
<T> T get(Function<String,T> stringFunc, Function<Double,T> doubleFunc);
class StringVersion implements StringOrDouble {
private final String string;
public StringVersion(String string) {
this.string = string;
}
@Override
public <T> T get(Function<String, T> stringFunc, Function<Double, T> doubleFunc) {
return stringFunc.apply(string);
}
}
class DoubleVersion implements StringOrDouble {
private final Double doubleValue;
public DoubleVersion(Double doubleValue) {
this.doubleValue = doubleValue;
}
@Override
public <T> T get(Function<String, T> stringFunc, Function<Double, T> doubleFunc) {
return doubleFunc.apply(doubleValue);
}
}
static StringOrDouble ofString(String string) {
return new StringVersion(string);
}
static StringOrDouble ofDouble(Double doubleValue) {
return new DoubleVersion(doubleValue);
}
public static void main(String[] args) {
StringOrDouble[] vs = {ofString("hello"),ofDouble(101.0)};
for (StringOrDouble v : vs) {
System.out.println(v.get(String::toUpperCase, Double::toHexString));
}
}
}

And then use:

List<ImmutablePair<Integer, StringOrDouble>> params;

Or a generic version:

import java.util.List;
import java.util.function.Function;
public interface Union<A, B> {
<T> T get(Function<A, T> aFunc, Function<B, T> bFunc);
class AVersion<A, B> implements Union<A, B> {
private final A a;
public AVersion(A a) {
this.a = a;
}
@Override
public <T> T get(Function<A, T> aFunc, Function<B, T> bFunc) {
return aFunc.apply(a);
}
}
class BVersion<A, B> implements Union<A, B> {
private final B b;
public BVersion(B b) {
this.b = b;
}
@Override
public <T> T get(Function<A, T> aFunc, Function<B, T> bFunc) {
return bFunc.apply(b);
}
}
static <A, B> Union<A, B> ofA(A a) {
return new AVersion<>(a);
}
static <A, B> Union<A, B> ofB(B b) {
return new BVersion<>(b);
}
public static void main(String[] args) {
List<Union<String, Double>> vs = List.of(ofA("hello"), ofB(101.0));
for (Union<String, Double> v : vs) {
System.out.println(v.get(String::toUpperCase, Double::toHexString));
}
}
}

We can also add a method to Union:

    default void use(Consumer<A> aConsumer, Consumer<B> bConsumer) {
get(a -> {aConsumer.accept(a); return null;}, b -> {bConsumer.accept(b); return null;});
}

Which allows us to pass void methods, so if we have a bean like:

class Foo {
private String s;
private double d;
public String getS() {
return s;
}
public void setS(String s) {
this.s = s;
}
public double getD() {
return d;
}
public void setD(double d) {
this.d = d;
}
}

we can do:

        Union<String, Double> u = ofA("a string");
Foo f = new Foo();
u.use(f::setS, f::setD);

And the appropriate setter will be called.

Not completely sure if I read the question correctly, but a very easy way to implement a union type would be:

public class Union<A, B> {
private final A a;
private final B b;
private Union(A a, B b) {
this.a = a;
this.b = b;
}
public boolean isA() {
return a != null;
}
public boolean isB() {
return b != null;
}
public A getA() {
if(isA()) {
return a;
}
throw new NoSuchElementException();
}
public B getB() {
if(isB()) {
return b;
}
throw new NoSuchElementException();
}
public static <A, B> Union<A, B> ofA(A a) {
return new Union<A, B>(Objects.requireNonNull(a), null);
}
public static <A, B> Union<A, B> ofB(B b) {
return new Union<A, B>(null, Objects.requireNonNull(b));
}
}

If you don't use generics you could also drop the static of methods and simply use two different constructors but with generics that won't work because of the type erasure.

You'd call is like this:

Union<String, Double> union = Union.ofA("bla");
if(union.isA()) {
System.out.println(union.getA());
}
if(union.isB()) {
System.out.println(union.getB());
}