LDM Notes for February 1st, 2023

[MadsTorgersen]

https://github.com/dotnet/csharplang/blob/main/meetings/2023/LDM-2023-02-01.md

Agenda

• Position of unsafe in aliases
• Roles and extensions

[yaakov-h]

I feel like there's a slight discrepancy between:

Whenever [an extension] is in scope or imported with a using directive, the extension applies to its underlying type.

and:

If/when we get to phase "C", this becomes more important, as an extension can implement additional interfaces on behalf of its underlying type, and therefore needs to be able to be passed as a type argument for type parameters constrained by such interfaces.

Assuming I have the following setup for phase C:

class Foo { ... }
extension FooExtension : Foo, ICloneable { ... }

class Please
{
    public static bool Clone<TCloneable>(TCloneable obj) where TCloneable : ICloneable { ...}
}

Based on the first quote, I would expect to be able to call Please.Clone(foo) i.e. Please.Clone<Foo>(foo).

The second quote indicates that instead I would need to call Please.Clone<FooExtension>(?).

Which direction would phase C be heading in, and why?

[YairHalberstadt]

Looking at the note for the roles WG something doesn't make sense to me:

The intent is to emit List<Role> as List<Underlying> and then only convert on usage.

In phase C though you want to allow a Role to implement an interface.

So if I have class X<T> where T : IInterface, and role Role int, IInterface, how is X<Role> emitted?

[qrli]

Will you be able to tell roles apart with pattern matching? No, from a runtime perspective they represent the same underlying type, which is the thing we can check for at runtime.

This is a bit surprise. While roles have types and can even implement interfaces in phase "C", they cannot be type-tested?
Or, do you mean that "it cannot tell roles of the same underlying type apart"?

[FaustVX]

Will you be able to tell roles apart with pattern matching? No, from a runtime perspective they represent the same underlying type, which is the thing we can check for at runtime.

It could be nice to have a feature to check if a type can be casted to a role (may be not in the first phase, but for a later phase) with some sort of a Validate method:

role Email for string
{
  public static bool Validate(string s)
  => // Check if the string is an e-mail

  public URI Domain => // part of e-mail after the @

  public void Send(string message)
  => // Send the message to the e-mail
}

if ("[email protected]" is Email { Domain: var domain } mail) // calls the Validate method
  // Do something with the mail and domain

[FaustVX]

I've already discussed with @HaloFour #5496 (comment) about that.
And we both agreed with the merge of a Validation and some pattern matching

role Even for int where this % 2 is 0 { }
int value = 123;
if (value is Even even) {
    even.SomeMember(); // access members of the Even role here
}

[mungojam]

I love reading the LDM notes and have done so for years. I have to say though that Roles is the first major feature in them that I don't yet get. I'd love to see more real-world examples of it so that I can really get it and begin to follow along the decisions being made.