Implementation of union types in Java

When developing code, it is sometimes necessary for an object to contain values ​​of one type or values ​​of another type at some point. Programming languages ​​that support the concept of unions allow at a certain moment to save the current value in one memory area.



For example, in C / C ++ you can write like this.

union value { int i; float f; }; union value v; vi = 5; /* vf - undefined behaivor */
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Moreover, if we set the value to one field, then reading the value of another field will have undefined behavior.



To simplify working with union types in C ++ 17, the std :: variant class was added.

  std::variant<int, float> v { 5 }; std::cout << "int value: " << std::get<int>(v) << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

The Java language does not support union types. As an alternative, you can implement a data class with two fields of certain types with setters and getters. But I wanted the value to be stored in one field, and not in two.



As you know, the Object type can save the value of one type, and then reassign the values ​​of another type. And this can be used to implement a class, like the class std :: variant.



Since in Java you cannot specify a variable number of types in a generic, for a certain number of types you need a specialization of the class (Union2, Union3, etc.). Let's write the main class Union and its basic operations.

  public abstract class Union { private Union() {} public abstract <T> void set(T value); public abstract <T> T get(Class<T> clazz); public abstract <T> boolean isActive(Class<T> clazz); public abstract <T> Class<T> getActive(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

To create class objects, we will use factory methods. Depending on the number of types, the specific specialization of the class will be returned.

  public static <T1, T2> Union2<T1, T2> of(Class<T1> firstClass, Class<T2> secondClass) { return new Union2<>(firstClass, secondClass); } public static <T1, T2, T3> Union3<T1, T2, T3> of(Class<T1> firstClass, Class<T2> secondClass, Class<T3> thirdClass) { return new Union3<>(firstClass, secondClass, thirdClass); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

The concrete specialization of the union class will store a certain number of types and one field Object. If we indicate an incorrect type, we will get an error.

  private static class Union2<T1, T2> extends Union { private final Class<T1> firstClass; private final Class<T2> secondClass; private Object value; private Union2(Class<T1> firstClass, Class<T2> secondClass) { this.firstClass = firstClass; this.secondClass = secondClass; } @Override public <T> void set(T value) { if (value.getClass() == firstClass || value.getClass() == secondClass) { this.value = value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union two types: [" + firstClass.getName() + ", " + secondClass.getName() + "]"); } } @Override public <T> T get(Class<T> clazz) { if (clazz == firstClass || clazz == secondClass) { return (T) value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union two types: [" + firstClass.getName() + ", " + secondClass.getName() + "]"); } } @Override public <T> boolean isActive(Class<T> clazz) { return value.getClass() == clazz; } @Override public <T> Class<T> getActive() { return (Class<T>) value.getClass(); } } private static class Union3<T1, T2, T3> extends Union { private final Class<T1> firstClass; private final Class<T2> secondClass; private final Class<T3> thirdClass; private Object value; private Union3(Class<T1> firstClass, Class<T2> secondClass, Class<T3> thirdClass) { this.firstClass = firstClass; this.secondClass = secondClass; this.thirdClass = thirdClass; } @Override public <T> void set(T value) { if (value.getClass() == firstClass || value.getClass() == secondClass || value.getClass() == thirdClass) { this.value = value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union three types: [" + firstClass.getName() + ", " + secondClass.getName() + ", " + thirdClass.getName() + "]"); } } @Override public <T> T get(Class<T> clazz) { if (clazz == firstClass || clazz == secondClass || value.getClass() == thirdClass) { return (T) value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union three types: [" + firstClass.getName() + ", " + secondClass.getName() + ", " + thirdClass.getName() + "]"); } } @Override public <T> boolean isActive(Class<T> clazz) { return value.getClass() == clazz; } @Override public <T> Class<T> getActive() { return (Class<T>) value.getClass(); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Now let's look at an example of how to use this class. As you can see, Union does not work with specific specializations, which makes the code simpler.

  Union triUnion = Union.of(Integer.class, String.class, Float.class); triUnion.set(15f); assertEquals(triUnion.getActive(), Float.class); assertTrue(triUnion.isActive(Float.class)); triUnion.set("Dot"); assertEquals(triUnion.getActive(), String.class); assertTrue(triUnion.isActive(String.class)); triUnion.set(10); assertEquals(triUnion.getActive(), Integer.class); assertTrue(triUnion.isActive(Integer.class));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

You can also write a simple visitor to check the current value.

  Union biUnion = Union.of(Integer.class, String.class); biUnion.set("Line"); Union triUnion = Union.of(Integer.class, String.class, Float.class); triUnion.set(15f); matches(biUnion, Integer.class, i -> System.out.println("bi-union number: " + i), String.class, s -> System.out.println("bi-union string: " + s) ); matches(triUnion, Integer.class, i -> System.out.println("tri-union int: " + i), String.class, s -> System.out.println("tri-union string: " + s), Float.class, f -> System.out.println("tri-union float: " + f) );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

  public static <V, T1, T2> void matches(V value, Class<T1> firstClazz, Consumer<T1> firstConsumer, Class<T2> secondClazz, Consumer<T2> secondConsumer) { Class<?> valueClass = value.getClass(); if (firstClazz == valueClass) { firstConsumer.accept((T1) value); } else if (secondClazz == valueClass) { secondConsumer.accept((T2) value); } } public static <T1, T2, T3> void matches(Union value, Class<T1> firstClazz, Purchaser<T1> firstConsumer, Class<T2> secondClazz, Purchaser<T2> secondConsumer, Class<T3> thirdClazz, Purchaser<T3> thirdConsumer) { Class<?> valueClass = value.getActive(); if (firstClazz == valueClass) { firstConsumer.obtain(value.get(firstClazz)); } else if (secondClazz == valueClass) { secondConsumer.obtain(value.get(secondClazz)); } else if (thirdClazz == valueClass) { thirdConsumer.obtain(value.get(thirdClazz)); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Summing up, we can say that in the Java language, support for union types can be implemented at the library level. But as a drawback, for each number of types you need your own specialization of the union class and additionally save all types.



The full source code of the class can be viewed on github: code