Proposal: Switch pattern for generic Type

[Khaos66]

This is what's possible today:

public T As<T>()
{
   T x = default;
   return x switch
   {
      int when _value is T i => i,
      long when _value is T l => l,
     _ => default
   }
}

This works fine while T is a primitive type, like int and long. But it's causing memory overhead for complex custom structs. That's because the line T x = default creates a new instance of the struct because structs can't be null. Depending on the struct this can be memory intenstive.

Something like this would therefore be appreciated:

public T As<T>()
{
   return T switch
   {
      int when _value is T i => i,
      long when _value is T l => l,
     _ => default
   }
}

I simplified the code a lot, I know it isn't very usefull in this state, but it serves the purpose of demonstrating the issue

[DavidArno]

See eg #356.

As to your example, I appreciate you have "simplified the code a lot", but as it stands, your As<T> method can be simplified to:

 public T As<T>() => _value is T x ? x : default;

Or, if you prefer a switch expression:

public T As<T>() => _value switch {
    T i => i,
    _ => default
};

There is no need to create x here. But maybe it is really needed in the true code.

[Khaos66]

@DavidArno Thank you for the input!
With 'simplified' I meant, that I removed some method calls... But as it turns out they are needed for the example...

private int ToInt() => _value switch {
   int i => i,
   long l => (int)l,
   _ => default
}

private int ToLong() => _value switch {
   int i => i,
   long l => l,
   _ => default
}

public T As<T>()
{
   T x = default;
   return x switch
   {
      int when ToInt() is T i => i,
      long when ToLong() is T l => l,
     _ => default
   }
}

My real use case is not about int and long, but more complex structs of our framework. This is just an example.

[bernd5]

What you could do today is:

using System;

var c = new Container<int>(12);
var l = c.As<long>();
Console.WriteLine(l);

class Container<X>
{
    X _value;

    public Container(X value)
    {
        _value = value;
    }

    private int ToInt() => _value switch
    {
        int i => i,
        long l => (int)l,
        _ => default
    };

    private long ToLong() => _value switch
    {
        int i => i,
        long l => l,
        _ => default
    };

    public T? As<T>()
    {
        return typeof(T) switch
        {
            var t when t == typeof(int) => Cast(ToInt()),
            var t when t == typeof(long) => Cast(ToLong()),
            _ => throw null
        };
		
        T? Cast<S>(in S s){
	        ref var refVar = ref System.Runtime.CompilerServices.Unsafe.AsRef<S>(s);
	        ref T? refT = ref System.Runtime.CompilerServices.Unsafe.As<S, T>(ref refVar);
	        return refT;
        }
    }
}

[Khaos66]

continues in #356