Proposal: code generation for union types

[hez2010]

Proposal: Code generation for union types

I'm planning to resolve #5 in near future.

Since C# doesn't support union types, we have to use a struct with implicit casting for each type of the union to implement this.

For example, a union type int | float | string will be lowered to below C# code with this proposal (not sure about whether we should use nullable types or not here):

class StringIntFloatUnionJsonConverter : System.Text.Json.Serialization.JsonConverter<StringIntFloatUnion>
{
    public override StringIntFloatUnion Read(ref System.Text.Json.Utf8JsonReader reader, System.Type type, System.Text.Json.JsonSerializerOptions options)
    {
        try
        {
            return new StringIntFloatUnion { IntValue = System.Text.Json.JsonSerializer.Deserialize<int>(ref reader, options) };
        }
        catch (System.Text.Json.JsonException) { }
        
        try
        {
            return new StringIntFloatUnion { FloatValue = System.Text.Json.JsonSerializer.Deserialize<float>(ref reader, options) };
        }
        catch (System.Text.Json.JsonException) { }
        
        try
        {
            return new StringIntFloatUnion { StringValue = System.Text.Json.JsonSerializer.Deserialize<string>(ref reader, options) };
        }
        catch (System.Text.Json.JsonException) { }
        
        return default;
    }
    
    public override void Write(System.Text.Json.Utf8JsonWriter writer, StringIntFloatUnion value, System.Text.Json.JsonSerializerOptions options)
    {
        if (value.Type == typeof(int)) { System.Text.Json.JsonSerializer.Serialize(writer, value.IntValue, options); return; }
        if (value.Type == typeof(float)) { System.Text.Json.JsonSerializer.Serialize(writer, value.FloatValue, options); return; }
        if (value.Type == typeof(string)) { System.Text.Json.JsonSerializer.Serialize(writer, value.StringValue, options); return; }
        writer.WriteNullValue();
    }
}


[System.Text.Json.Serialization.JsonConverter(typeof(StringIntFloatUnionJsonConverter))]
struct StringIntFloatUnion
{
    private int? intValue;
    private float? floatValue;
    private string? stringValue;
    
    public int? IntValue
    {
        get => intValue;
        set
        {
            ClearValue();
            intValue = value;
            Type = typeof(int);
        }
    }
    
    public float? FloatValue
    {
        get => floatValue;
        set
        {
            ClearValue();
            floatValue = value;
            Type = typeof(float);
        }
    }
    
    public string? StringValue
    {
        get => stringValue;
        set
        {
            ClearValue();
            stringValue = value;
            Type = typeof(string);
        }
    }
	
    private void ClearValue()
    {
        intValue = null;
        floatValue = null;
        stringValue = null;
        Type = null;
    }
    
    public System.Type? Type { get; private set; }
    
    public static implicit operator StringIntFloatUnion(int value)
    {
        return new StringIntFloatUnion { IntValue = value };
    }
    
    public static implicit operator StringIntFloatUnion(float value)
    {
        return new StringIntFloatUnion { FloatValue = value };
    }
    
    public static implicit operator StringIntFloatUnion(string value)
    {
        return new StringIntFloatUnion { StringValue = value };
    }
    
    public static implicit operator int?(StringIntFloatUnion value)
    {
        return value.IntValue;
    }
    
    public static implicit operator float?(StringIntFloatUnion value)
    {
        return value.FloatValue;
    }
    
    public static implicit operator string?(StringIntFloatUnion value)
    {
        return value.StringValue;
    }
    
    public override string? ToString()
    {
        if (Type == typeof(int)) return IntValue?.ToString();
        if (Type == typeof(float)) return FloatValue?.ToString();
        if (Type == typeof(string)) return StringValue?.ToString();
        return null;
    }
    
    public override int GetHashCode()
    {
        if (Type == typeof(int)) return IntValue?.GetHashCode() ?? 0;
        if (Type == typeof(float)) return FloatValue?.GetHashCode() ?? 0;
        if (Type == typeof(string)) return StringValue?.GetHashCode() ?? 0;
        return 0;
    }
}

Then we can use it as follows:

StringIntFloatUnion x = 4;
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(x));
x = 4.6f;
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(x));
x = "hello";
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(x));
Console.WriteLine(System.Text.Json.JsonSerializer.Deserialize<StringIntFloatUnion>("4").ToString());
Console.WriteLine(System.Text.Json.JsonSerializer.Deserialize<StringIntFloatUnion>("4.6").ToString());
Console.WriteLine(System.Text.Json.JsonSerializer.Deserialize<StringIntFloatUnion>("\"hello\"").ToString());

which outputs:

4
4.6
hello
4
4.6
hello

If anyone has ideas about how this feature should be implemented, feel free to reply in this discussion.

Thanks for using TypedocConverter.

[fgoulet]

One option would be using this library https://github.com/mcintyre321/OneOf

OneOf<string, int, float> x= 4;
x =  4.6f;
x = "hello"

[hez2010]

Initial implementation added.