[Proposal]: Implicit Interface with mandatory default implementations

[Caracrist]

Proposal: Implicit Interfaces in C#

This proposal introduces a new type of interface in C#, called an implicit interface.

In this model, all other interfaces would be considered “explicit” (with an optional keyword for backward compatibility). Implicit interfaces aim to enhance the language’s flexibility by allowing interfaces to group existing interfaces with mandatory default implementations of new functions and properties (a feature introduced in C# 8.0). This approach adds new ways to manage and utilize interfaces without requiring modifications to existing implementation classes.

Proposed Feature

Implicit Interface:
An implicit interface is a specialized type of interface characterized by the following:

1. Contents
   An implicit interface can only contain methods and properties that are new additions, with mandatory default implementations provided in the interface itself.

2. Inheritance and Implementation

   • An implicit interface can inherit from any number of other interfaces, implicit or explicit.
   • It can be implemented by any class in the same way as any other interface.
   • Any class can implement any number of implicit or explicit interfaces.

3. Implicit Conversion

   • The key feature is implicit conversion to the implicit interface type without the requirement to implement it.
   • Any type that implements all the non-implicit (explicit) interfaces inherited by the implicit interface can be implicitly converted to this type, including the behavior of existing operators is and as and generic where type matching.
   • Implicit interfaces cannot override existing members of the inherited interfaces but can add new methods and properties with mandatory default implementations.

4. New Operators

   • is explicit operator: Returns true only if the actual type explicitly implements the interface on the right value.
   • as explicit operator: Attempts to cast a type to the implicit interface, returning the cast only if the type can be converted to the implicit interface and explicitly implements it.
   • where (generic type constraint): explicit: Using the keyword explicit before an interface name in the where clause should restrict the matching for types that implement that interface explicitly only.
   • explicit cast operator: Adding the keyword explicit before the interface name in the cast operator, like this: (explicit Interface)instance, would restrict the cast operation to succeed only if the instance type implements that interface explicitly.
   • is implicit, as implicit, (implicit Interface) cast operators, and where : implicit clause: These operators and clause should be added for the sake of symmetry and act identically to the existing is, as, and cast operators, and existing where clause.

Key Benefits

1. Non-Breaking Extensions
   Implicit interfaces allow for the non-breaking introduction of new members to existing interfaces, especially those based on multiple base interfaces. This feature is highly beneficial in evolving APIs and libraries without requiring changes to existing implementations.

   Examples:

   • Extending Existing Interfaces
     Implicit interfaces enable extending existing interfaces with additional functionality without altering the existing implementations. This is particularly valuable in scenarios involving widely used interfaces like ILogger.

     public interface ILogger
     {
         void Log(string message);
         void Error(string message);
     }
     
     public implicit interface IFatalLogging : ILogger
     {
         void Fatal(string message) => Error($"Fatal: {message}");
     }

     Now, any class implementing ILogger can be implicitly treated as implementing IFatalLogging, and the Fatal method can be called without modifying the existing classes:

     public class ConsoleLogger : ILogger
     {
         public void Log(string message) => Console.WriteLine($"Log: {message}");
         public void Error(string message) => Console.WriteLine($"Error: {message}");
     }
     
     public class Application
     {
         public void Run(IFatalLogging logger)
         {
             // Implicit conversion to IFatalLogging
             logger.Fatal("A fatal error occurred.");
         }
     }
     
     // Usage
     ILogger logger = new ConsoleLogger();
     new Application().Run(logger); // Outputs: Error: Fatal: A fatal error occurred.

   • Grouping Interfaces
     Implicit interfaces provide a way to group multiple interfaces and use this grouping to access the collective functionality. This feature offers a cleaner way to handle complex scenarios where a class needs to implement a collection of interfaces without cluttering the class design.

     Example:

     Suppose you have multiple interfaces related to file operations:

     public interface IReadable
     {
         void Read();
     }
     
     public interface IWritable
     {
         void Write();
     }

     An implicit interface IReadWrite can group them:

     public implicit interface IReadWrite : IReadable, IWritable
     {
         // No new methods or properties; purely groups existing interfaces.
     }

     Any class that implements both IReadable and IWritable will automatically be considered as implicitly implementing IReadWrite. For example:

     public class File : IReadable, IWritable
     {
         public void Read() => Console.WriteLine("Reading from file.");
         public void Write() => Console.WriteLine("Writing to file.");
     }
     
     public void Func(IReadWrite file)
     {
         file.Read();
         file.Write();
     }
     
     // Usage
     Func(new File());

     This approach makes code management cleaner and more intuitive.

   • Grouping and Extending
     Implicit interfaces can also group and extend existing interfaces simultaneously. For example, an implicit interface could combine IFlyable and ISwimmable while adding new functionality.

     Example:

     Suppose we have:

     public interface IFlyable
     {
         void Fly();
     }
     
     public interface ISwimmable
     {
         void Swim();
     }
     
     public implicit interface IAquaticBird : IFlyable, ISwimmable
     {
         void Dive() => Console.WriteLine("Diving with default behavior.");
     }

     Any class implementing IFlyable and ISwimmable can be implicitly treated as IAquaticBird, gaining the new Dive functionality without modifying the existing classes. For example:

     public class Duck : IFlyable, ISwimmable
     {
         public void Fly() => Console.WriteLine("Flying.");
         public void Swim() => Console.WriteLine("Swimming.");
     }
     
     // Usage
     var duck = new Duck();
     ((IAquaticBird)duck).Dive(); // Outputs: Diving with default behavior.

Conclusion

The introduction of implicit interfaces in C# would significantly enhance the interface-based programming model by allowing non-breaking extensions and grouping of related interfaces. By adding new members with default implementations, implicit interfaces enable more dynamic and flexible ways to extend and manage interfaces, making C# an even more powerful and adaptable language for developers.

[timcassell]

This sounds like a less useful version of extensions. #5497

[333fred]

To put it simply: what happens at runtime when the program sees multiple implicit implementations for the same interface?

[Caracrist]

In .NET, the matching of a candidate function, such as a method or an overload, happens at compile time based on the static type of the object and the arguments provided. So at runtime you are past resolution. This is why I classified it as Category 2 change and not Category 1, because rebuild (reevaluation of candidate function without code changes) is required.

[333fred]

Extensions would also require the same type of change. What does your proposal add that it does not?

[Caracrist]

How is adding implicit extension for every Duck considered as same type of change as rebuild with no changes? Is it possible, what me and timcassell missed something and it is possible to make no changes in the code and not to break anything?

[333fred]

How is adding implicit extension for every Duck

You wouldn't. You'd do exactly the same thing that you're proposing here.