Proposal: Implicit Generic Parameters ✨

[fydar]

Brief

// Before
int result = UseFactory<IntegerFactory, int>();

// After
int result = UseFactory<IntegerFactory>();

Motivation

Take the following API.

public interface IFactory<TValue>
{
    public TValue Generate();
}

public struct IntegerFactory : IFactory<int>
{
    public int Generate() => 10;
}

Now if we have a generic method that utilises this API, it might look like the following:

public void Test()
{
    int result = UseFactory<IntegerFactory, int>();
}

public TValue UseFactory<TFactory, TValue>()
    where TFactory : struct, IFactory<TValue>
{
    var factory = default(TFactory);

    return factory.Generate();
}

When using UseFactory<IntegerFactory, int>(); you have to supply int every time, regardless of it being the only valid generic option.

Solution 1

This proposal seeks to add Implicit Generic Parameters.

public void Test()
{
	int result = UseFactory<IntegerFactory>();
}

public TValue UseFactory<TFactory, implicit TValue>()
	where TFactory : struct, IFactory<TValue>
{
	var factory = default(TFactory);
	return factory.Generate();
}

Resolving Ambiguity, Multiple Generic Types

When multiple implicit generic arguments are available, explicit generic types must be supplied to resolve the ambiguity; resulting in identical code to what might have been before.

public void Test()
{
        // Error: Ambiguous implicit parameter type between 'int' and 'string'.
	var resultA = UseFactory<MultiFactory>();
}

public struct MultiFactory : IFactory<int>, IFactory<string>
{
	int IFactory<int>.Generate() => 10;

	string IFactory<string>.Generate() => "Hello World";
}

Resolving Ambiguity, Inheritance and Multiple Generic Types

When a single interface implementation is available on the type supplied (despite it inheriting the interface implementation on the base type) then the ambiguity is resolved using that single generic type.

public void Test()
{
        // Compiles successfully
	string result = UseFactory<StringFactoryAndIntegerFactory>();
}

public TValue UseFactory<TFactory, implicit TValue>()
	where TFactory : class, new(), IFactory<TValue>
{
	var factory = new TFactory();
	return factory.Generate();
}

public class IntegerFactory : IFactory<int> { /* ... */ }

public class StringFactoryAndIntegerFactory : IntegerFactory , IFactory<string> { /* ... */ }

[HaloFour]

See: #1349