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.

[IlyaVassyutovich]

Thank you for your incredibly detailed explanation. And incredible product of LanguageExt. This is how I'm learning FP.

I'm also with you about sacrificing forward compatibility for backward compatibility, yet here we are.

Have a great day!