DomainType.FromUnsafe

[IlyaVassyutovich]

Hello there!

I'm trying v5 of LanguageExt. There is a new way to define domain types — trait DomainType2. There is a static virtual method FromUnsafe` in this interface with default implementation. But I don't quite undersand how to use it.

internal sealed class Hostname(string value) : DomainType<Hostname, string>
{
	// Imagine there is actually a proper hostname validation
	public static Fin<Hostname> From(string repr) => new Hostname(repr);

	public string To() => value;
}

internal static class Hostnames
{
	// CS0117 'Hostname' does not contain a definition for 'FromUnsafe'
	public static readonly Hostname Shmoogl = Hostname.FromUnsafe("shmoogle.com");
}

In my head Shmoogl member initialization should work "out of the box", but I get a compler error shown in the comment. Why so? Am I missing something? Must admit, that statics and/or virtuals in interfaces are somethings I'm not very familiar.

[louthy]

Unfortunately, the C# language team, in their infinite wisdom, crippled the static-method interface system in the name of "backwards compatibility". There were some minor edge-cases where adding a static method after-the-fact to an interface might change the behaviour of the derived types that never saw that method before.

So, instead of just accepting this edge-case and informing programmers to watch out for this issue and have a 1 time fix-up for the edge-cases... they instead compromised all future code written with this feature. Thanks Microsoft.

The crux of it is this:

You cannot directly invoke a default static method. i.e.

public interface Base
{
    static virtual int Foo() =>
        100;
}

// ERROR: A static virtual or abstract interface member can be accessed only on a type parameter
var x = Base.Foo(); 

If you create a type that derived from the Base, you still can't invoke the static method. i.e.

public interface Base
{
    static virtual int Foo() =>
        100;
}

public class Derived : Base
{
}

// ERROR: Cannot resolve symbol 'Foo'
var x1 = Derived.Foo();

Yep, you can't access the member that Derived has inherited via Derived. It's idiotic.

You can override the implementation, which gives you access to the Base

public interface Base
{
    static virtual int Foo() =>
        100;
}

public class Derived : Base
{
    public static int Foo() =>
        200;
}

// COMPILES!
var x1 = Derived.Foo();

Presumably, we can access the base implementation from the derived type? Don't be silly:

public class Derived : Base
{
    public static int Foo() =>
        // ERROR: Cannot use 'base' in static member
        base.Foo();
}

public class Derived : Base
{
    public static int Foo() =>
        // ERROR: A static virtual or abstract interface member can be accessed only on a type parameter
        Base.Foo();
}

So, how to we access the base implementation!?

The clue is in the error message: "A static virtual or abstract interface member can be accessed only on a type parameter". We must create access via a constrained generic type parameter:

public static class BaseModule
{
    public static int Foo<T>() where T : Base =>
        T.Foo();
}

Then we can access it via the generic method:

var x = Derived.Foo(); // 200
var y = BaseModule.Foo<Derived>(); // 200
var z = BaseModule.Foo<Base>(); // 100

That means you don't need to override it in the derived type.

And that's how most of the traits work in language-ext, through generic 'module' functions and generic extension-methods. It causes me to have to write twice as much code to support traits because the static abstract and static virtual methods are not made available by-default.

And frankly, it pisses me off that all future code has been compromised because of some small backwards compatibility edge-cases that could be overcome with programmer care, once. I'm all for backwards compatibility, I think it's great that 20 year old C# code will compile, but backwards compatibility at the expense of forward capability is utterly misguided.

/rant

TL;DR: If you want the *Unsafe variant to be publicly accessible, you must create your own overload or use the generics-technique listed above.