Proposal: Function Parameter Type Converters

[TonyValenti]

Function Parameter Type Converters

Summary

This proposal provides a compiler construct that eliminates the need to generate multiple method overloads for similar objects. This will eliminate boilerplate code and simplify method design.

Motivation

Often when writing APIs, developers are forced to provide multiple overloads to a function to accommodate different-yet-similar parameter types. For example, a class may have multiple overloads of a "DeleteUser" method as follows:

public static void DeleteUser(Portal P, User U) {
  DeleteUser(P, User.ID);
}

public static void DeleteUser(Portal P, User[] Users){
  DeleteUser(P, Users.Select(u => U.ID).ToArray());
}

public static void DeleteUser(Portal P, long ID){
  DeleteUser(Portal P, new long[]{ID});
}

public static void DeleteUser(Portal P, long[] UserIDs){
 //Actually delete the user.
}

In the design above, adjusting the method to allow single or multiple P's that are either Portal's or long's would result in NxM additional overloads being necessary (in this case, 16 different variants).

Detailed Design

Introduce ParameterConverterAttribute<T> and IParameterConverter<TIn, TOut>

ParameterConverterAttribute is a generic attribute that takes the type of an object that implements one or more IParameterConverter interfaces.

The implementation below would accommodate all 16 variants of the above method:

public class IdConverter<T> where T : IDBase
 : IParameterConverter<T, long[]>
 , IParameterConverter<T[], long[]>
 , IParameterConverter<long, long[]> {

  long[] IParameterConverter<T,long[]> Convert(T U) {
	return new long[]{U.ID};
  }

  long[] IParameterConverter<T,long[]> Convert(T[] U) {
	return U.Select(x => x.Id).ToArray();
  }

  long[] IParameterConverter<long,long[]> Convert(long Value) {
	return new long[]{Value};
  }

}

public static void DeleteUsers([ParameterConverter<IdConverter<Portal>>] long[] PortalId,  [ParameterConverter<IdConverter<User>>] long[] UserIDs){
 
}

Editor Experience

When programming through Visual Studio, automatic parameter conversions could be displayed as follows:

This makes it easy for the developer to understand that some magic is happening while still making it clear what is happening. This is somewhat similar to how extension methods surface.

Considerations and Objections

Call-Site Conversions and Extension Methods

It is possible to design extension methods that would handle the conversion, however, extension methods:

• Require an explicit call-site invocation. ie. DeleteUsers(Portal.ToIdArray(), User.ToIdArray())
• Requires an explicit using statement for the namespace
• Clutter the members shown in Visual Studio

Type Converters

Someone might propose adding type converters to the class:

public static implicit operator long(IDBase Item) {
    return Item.ID;
}

public static implicit operator long[](IDBase Item) {
    return new long[]{ Item.ID };
}

However, this is only possible if you can edit the source code of the class itself.

Discriminated Unions

Although discriminated unions are not yet part of C#, this approach would somewhat simplify the challenge, although not fully, because it would force the function writer to deal with the different types inside of the function itself. This is arguably worse than exposing multiple overloads because of the extra cases it introduces in the method body.

For example:

public string Pad(string Value, int|string Padding){
 var ret = "";
 if(Padding is int i){
   ret += new String(' ', i);
 } else if (Padding is string S){
  ret += S;
}

 ret += Value;
 return ret;
}

Static Methods

Instead of using an instance class, it may be possible to look up a static member on the type provided to the ParameterConverter. I'm unsure of the implementation details, but this would be a good idea.

[Unknown6656]

This does sound like a strong case for discriminated unions, doesn't it?
#113
#78
dotnet/roslyn#188

[TonyValenti]

@Unknown6656 -
The challenge with discriminated unions is that inside your function, you still have to deal with each option for a type. In this proposal, it elminiates that need because, by the time the method is invoked, you are guaranteed to have the parameter of a single type.

[HaloFour]

Overloading is already one of the most complicated aspects of the C# language, having some arbitrary converter in front of that which can convert between arbitrary types seems like it would explode into a Cartesian product of problems.

[Unknown6656]

@TonyValenti

The challenge with discriminated unions is that inside your function, you still have to deal with each option for a type. In this proposal, it elminiates that need because, by the time the method is invoked, you are guaranteed to have the parameter of a single type.

I may be mistaken, but you would only have to write one extension method addressing the union. In this method you would write your converter logic, e.g.:

// this is just an example syntax ..... you get the idea ^^
public class MyUnion = long A | long[] B | Portal C | Portal[] D;


public static class MyExtensions
{
    public static T ConvertTo<T>(this MyUnion obj) =>
        obj switch {
            // switch on the union and return the converted values
            MyUnion.A a => ...
            MyUnion.B b => ...
            MyUnion.C c => ...
            MyUnion.D d => ...
        }

    public static void MyMethod()
    {
        MyUnion u = new[] { 42L, -4L, 77L };
        int i = u.ConvertTo<int>();
    }
}

[TonyValenti]

Hi All,
I wanted to let you know I've come up with an idea that gets me pretty close to what I was wanting to do.

What are your thoughts around this code?

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp29 {
    class Program {
        static void Main(string[] args) {
            Foo(new Byte[] { 1, 2, 3, 4, 5 });
            Foo(new MemoryStream(new byte[] { 6, 7, 8, 9, 10 }));
        }

        public static void Foo(ByteOrStreamAsStream Data) {

            for (var Number = Data.Converted.ReadByte(); Number != -1; Number = Data.Converted.ReadByte()) {
                Console.WriteLine(Number);
            }

        }

    }


    public class ByteOrStreamAsStream : Converter<Byte[], Stream> {
        protected override void ImportInternal(byte[] Source) {
            this.Converted = new MemoryStream(Source);
        }

        public static implicit operator ByteOrStreamAsStream(Byte[] Source) => new ByteOrStreamAsStream().Then( x=> x.ImportInternal(Source));
        public static implicit operator ByteOrStreamAsStream(Stream Source) => new ByteOrStreamAsStream().Then(x => x.ImportInternal(Source));

    }

    public abstract class Converter<T0, T9> {

        public T9 Converted { get; protected set; }

        protected abstract void ImportInternal(T0 Source);

        protected void ImportInternal(T9 Source) {
            Converted = Source;
        }
    }

    public static class Extensions {
        public static T Then<T>(this T This, Action<T> Action) {
            Action(This);
            return This;
        }
    }

}