generic constrain to allow only ref structs

[BarionLP]

Not sure if I'm missing something but with the new allow ref struct thing it should also be possible to create a constrain that only allows ref structs.
e.g. I was just trying to add this one of my projects and came across multiple situations where I need different behavior for ref structs compared to normal structs and classes. but right now i can only differenciate between struct and class.
Is this a design oversight? Are there plans to add this in C# 14? Or was this specifically rejected?

Edit for clarity:
Currently this is valid C#:

"".Foo(); // ClassWrapperExtensions.ToWrapper
1.Foo(); // StructWrapperExtensions.ToWrapper

public static class ClassWrapperExtensions
{
    public static ClassWrapper<T> ToWrapper<T>(this T value) where T : class { }
}

public static class StructWrapperExtensions
{
    public static StructWrapper<T> ToWrapper<T>(this T value) where T : struct { }
}

I want to extend this to also cover ref structs (in my use case i only need ref struct or not ref struct)

"".Foo(); // ClassWrapperExtensions.ToWrapper
1.Foo(); // StructWrapperExtensions.ToWrapper
Span<byte>.Empty.Foo(); // RefWrapperExtensions.ToWrapper

public static class ClassWrapperExtensions
{
    public static ClassWrapper<T> ToWrapper<T>(this T value) where T : class { }
}

public static class StructWrapperExtensions
{
    public static StructWrapper<T> ToWrapper<T>(this T value) where T : struct { }
}

public static class RefWrapperExtensions
{
    public static RefWrapper<T> ToWrapper<T>(this T value) where T : ref struct { }
}

[CyrusNajmabadi]

What's your use case for this?

[BarionLP]

What's your use case for this?

specifically i have two wrapper types, one feature rich for classes/structs and a stripped down version for ref structs. now i need a generic extension method that wraps ref structs in the stripped version and the others in the full version without any ambiguity. Of course I can just name it differently but then I have the problem that users might accidentally create a stripped version with a type that supports full functionality. Both versions are fully stack allocated (there is no notable overhead of the full version). So there is no reason to use the stripped version for classes/structs it's just that some features are not available, like obtaining the default equality comparer.

[BarionLP]

Think what you're looking for here is bridge constraints proposal

still need a different return type

[jaredpar]

I'm unsure though how you expect to use this. As I mentioned, you cannot overload methods based on constraints. So even if this constraint existed what would you do? Essentially, pretend for a moment that we had where T: ref struct and it was only satisfied for actual ref struct. What is the API that you would like to write?

[BarionLP]

What is the API that you would like to write?

doesn't the updated description make it clear?
its a ToOption extension method that either creates a struct Option (can be used in async / yield return) or a ref struct RefOption (has limitations).

As shown in the description it is possible to have a ClassOption and StructOption and have the compiler pick the correct extension method but i only need the ref struct and not ref struct separation

[colejohnson66]

Understandable, but is there a reason you need a RefOption<T>? Why wouldn't Option<T> where T : allows ref struct suffice?

[BarionLP]

Understandable, but is there a reason you need a RefOption<T>? Why wouldn't Option<T> where T : allows ref struct suffice?

so it can be used in async / yield return.
Also i need the EqualityComparer<T>.Default and override GetHashCode/ToString

[TahirAhmadov]

I think what you may be looking for is generic specialization:

class Wrapper<T> where T : allows ref struct
{
  // stripped down 
  public void ForEverything() { ... }
  // full featured
  public void ForClass() where T : class { ... }
  public void ForStruct() where T : struct { ... }
}

There probably are discussions (or even issues) requesting this.

[BarionLP]

functionality wise this isn't necessary right now (just with generic specialization this becomes mandatory)
but it would be nice to have to prevent unintended usage

[KennethHoff]

This sounds like you just want peace of mind as it seemingly wouldn't affect the API in any way, which is what analyzers were designed for. Create a [OnlyRefStructAttribute] which can be applied to type parameters and a corresponding analyzer that verifies it

[BarionLP]

This sounds like you just want peace of mind as it seemingly wouldn't affect the API in any way, which is what analyzers were designed for. Create a [OnlyRefStructAttribute] which can be applied to type parameters and a corresponding analyzer that verifies it

almost, it would affect extension method overload resolution (can i have one for struct and one for class in different classes but not for ref struct)
#8601 (reply in thread)

[CyrusNajmabadi]

it would affect extension method overload resolution

Constraints don't affect overload resolution.

[BarionLP]

it would affect extension method overload resolution

Constraints don't affect overload resolution.

it does with extensions methods

"".Foo(); //A.Foo
1.Foo(); //B.Foo

public static class A
{
    public static void Foo<T>(this T value) where T : class { }
}

public static class B
{
    public static void Foo<T>(this T value) where T : struct { }
}

i now want the same for ref struct

[huoyaoyuan]

Constraint that restricting scopes only are mostly suitable for analyzers. Constraints built-in into language should enable additional operations under the constraint.

Is there any operation you can do with an instance of ref struct, but not with a regular struct?

[BarionLP]

Is there any operation you can do with an instance of ref struct, but not with a regular struct?

no, I don't think so.
The only usecase would be overload resolution

1.Foo(); //this is ambiguous right now
Span<byte>.Empty.Foo();

public static class A
{
    public static void Foo<T>(this T value) 
    { 
        // something that cannot be done with ref structs and should be done for everything but ref structs
    }
}

public static class B
{
    public static void Foo<T>(this T value)  where T : allows ref struct //this would have to be ref struct only
    {
        //fallback logic for ref structs
     }
}

This would work with one for : struct and one for : class, which is why i wanted to do it this way.
B.Foo can of course just be A.FooRef and everything would work fine, it just looks ugly

[ufcpp]

Could better "Bestest Betterness" solve this issue?

using System.Runtime.CompilerServices;

"".M();

// Ambiguous before C# 7.3, but now resolvable. (Bestest betterness)
1.M();

// Improving "Bestest Betterness" rule could solve this issue?
((Span<int>)[]).M();

static class Extensions
{
    public struct ClassDummy;
    public struct StructDummy;
    public struct RefStructDummy;

    public static void M<T>(this T x, ClassDummy _ = default) where T : class { }
    public static void M<T>(this T x, StructDummy _ = default) where T : struct { }

    [OverloadResolutionPriority(-1)]
    public static void M<T>(this T x, RefStructDummy _ = default) where T : struct, allows ref struct { }
}

[BarionLP]

that looks interesting, it might do, (despite being ugly)