Proposal: Implicit generics parameters capture

[sedlacl]

Implicit generics parameters capture

• Proposed
• Prototype: Complete
• Implementation: In Progress
• Specification: Not Started

Summary

[summary]: Allow derive parameters using where condition

class Factory<T,TX> where T : IParametrizedClass<TX>
var x=Factory<MyParametrizedClass,>

Motivation

[motivation]: If you need to construct class and work with its generics parameters.

Example

public interface IParametrizedClass<in T>
{
    void Init(T param);
}
public class MyParametrizedClass:IParametrizedClass<string>
{
	public void Init(string param)
	{
	}
}



public class Factory<T, TX> where T : class,IParametrizedClass<TX>, new()
{
	public T CreateAndInit(TX param)
	{
          var instance = Activator.CreateInstance<T>();
          instance.Init(param);
          return instance;
         }
}



     
public void Test()
{
     //construct with implicit capture posibility - there can't be anything else than string because MyParametrizedClass is type of IParametrizedClass<string>
     Factory<MyParametrizedClass,> x=new Factory<MyParametrizedClass,>();
     x.CreateAndInit("Hello");
}

Detailed design

Type can be pretty safely inferred except example

public class MyParametrizedClass:IParametrizedClass<string>,IParametrizedClass<int>
{
	public void Init(string param)
	{
	}
	public void Init(int param)
	{
	}
}

in that case compiler will fail.

But developer can still use full syntax
Factory<MyParametrizedClass, string>

Drawbacks

Why should we not do this?

Alternatives

Unresolved questions

What parts of the design are still undecided?

Design meetings

Link to design notes that affect this proposal, and describe in one sentence for each what changes they led to.

[DavidArno]

Generally, I think adding the ability to omit generic parameters that can be inferred would be a great feature. However, I don't like the idea of having to explicitly tell the compiler that the type can be implied via an implicit keyword. It ought to be ... implicit:

class Factory<T,TX> where T : IParametrizedClass<TX> { ...

var x = Factory<MyParametrizedClass,>...

[sedlacl]

I agree, implicit keyword is not necessary :) I updated proposal.

[ghord]

We could also consider specifying that parameter is implicit in generic declaration:

class Factory<T, implicit TX> where T : IParameterizedClass<TX> 
{
    
}

...

var x = new Factory<MyParametrizedClass>(); //compiler uses generic class with correct inferred type

This way we avoid hanging commas in declaration, so that syntax looks much nicer.

Maybe this could even be extended to use cases like this:

class MyList<implicit T>  
{
    public MyList(IEnumerable<T> items) 
    {
        ...
    }
}

...

void MyMethod(IEnumerable<int> items)
{

   var myList = new MyList(items); //type MyList<int>
} 

[sedlacl]

When I made this proposal, I had same idea as @ghord , but I decided rather be explicit about generics parameters.

Generally I think, this can lead to "ghosts" during refactoring - if you look at code, you can't decide if it is generics class or not, you can't even tell which of generics variants it is.

Example

Tuple myTwoParams=new Tuple(0,0) // means Tuple<int,int> 
Tuple myThreeParams=new Tuple(0,0,0) // means Tuple<int,int,int>

There are many problems in this example

• in variable declaration - can you or you can't use implicit types?
• implicit typing will be made using constructors? What if both types will have two parameter constructors?

Maybe it will work in simplier examples and in advanced scenarios you can't use it.

But with omitting types, it will still work

Tuple<,> myTwoParams=new Tuple<,>(0,0) // means Tuple<int,int> 
Tuple<,,> myThreeParams=new Tuple<,,>(0,0,0) // means Tuple<int,int,int>

Ommiting generics parameters in type declaration is generic question. Maybe it shouldn't be allowed at all.

Tuple<int,int> myTwoParams=new Tuple<,>(0,0) // means Tuple<int,int> 
Tuple<int,int,int> myThreeParams=new Tuple<,,>(0,0,0) // means Tuple<int,int,int>
//or
var myTwoParams=new Tuple<,>(0,0) // means Tuple<int,int> 
var myThreeParams=new Tuple<,,>(0,0,0) // means Tuple<int,int,int>