Simulating associated types in C#

[2A5F]

using static Infer;

// Use interface covariance and contravariance to avoid passing all generic parameters
static class Infer
{
    public static In<T> In<T>() => null!;
    public static Out<T> Out<T>() => null!;
}

interface In<out T>;
interface Out<in T>;

// Can be associated with any other interface
interface IAssociatedStatic<out T>
{
    static abstract T Value { get; }
}

interface IAssociated<Self, out AssociatedType> 
    where Self : IAssociated<Self, AssociatedType>, 
        IAssociatedStatic<AssociatedType>;

class Foo : IAssociated<Foo, int>, IAssociatedStatic<int>
{
    public static int Value => default;
}

class Some 
{
    public R Get<T, R>(In<IAssociated<T, R>> _) 
        where T : IAssociated<T, R>, IAssociatedStatic<R> 
        => T.Value;

    public (In<T>, Some) With<T>() => (null!, this);
    
    public Pair<In<T>, Some> With1<T>() => default!;
}

static class SomeEx
{
    public static R Get<T, R>(this (In<IAssociated<T, R>>, Some) self)
        where T : IAssociated<T, R>, IAssociatedStatic<R> 
        => self.Item2.Get(self.Item1);
    
    public static R Get1<T, R>(this Pair<In<IAssociated<T, R>>, Some> self)
        where T : IAssociated<T, R>, IAssociatedStatic<R> 
        => self.Item2.Get(self.Item1);
}

// Only ValueTuple<> has type inference magic, custom structures not working
record struct Pair<A, B>(A Item1, B Item2) { }

class Use
{
    public static void Use1(Some some)
    {
        var a = some.Get(In<Foo>());  // infer int
        
        var b = some.With<Foo>().Get();  // infer int
        
        // var c = some.With1<Foo>().Get1(); // can not infer
    }
}

sharplab

[neon-sunset]

The children yearn for F#