Generics can’t infer second parameter? [duplicate]

by

C# has been designed to be a slightly less brain-bending language than C++.

In particular, I don’t think it’s a great idea to compare C# generics to C++ templates for various reasons – they’re fundamentally two really quite different approaches to accomplishing similar things in some situations. The C++ approach is certainly flexible in some ways – although it doesn’t allow (as I understand it) templates which only exist in binary form, or new template specializations to be created at execution time. Basically the C++ templating approach doesn’t sit well with the rest of how .NET fits together.

Now as for why you can’t specify some type arguments and allow others to be inferred (which is a language decision rather than a platform decision; I’m sure it would be feasible as far as .NET itself is concerned) – again, I believe this is for the sake of simplicity. Choosing the exact right method and the right type arguments is already extremely complicated in C# – more complicated than most C# developers can get their heads round. It involves:

  • Potentially considering methods up the type hierarchy from the compile-time type of the target
  • Overloading by number of parameters
  • Overloading by the number of type parameters
  • The effect of named arguments
  • The effect of optional parameters
  • The effect of generic type parameter constraints on parameter types (not constraints specified by the target method, note)
  • Method group to delegate conversions
  • Anonymous function conversions
  • Type inference for type arguments
  • Dynamic typing
  • Generic covariance and contravariance

Personally, I think that’s enough to get my head around, without allowing yet more possiblities via “M can still be a candidate if it has at least as many type parameters as specified type arguments”. Would you also want named type arguments and optional type parameters? 😉

I’ve looked at overloading quite a lot, following the spec thoroughly etc. I’ve found areas which make the language designers scratch their heads and try to work out what the compiler should do. I’ve found areas which the compiler definitely gets wrong. I wouldn’t want to add any more complexity here without a really good reason.

So yes, it’s basically for the sake of simplicity, and sometimes that’s a pain – but often you can work around it. For every potential feature, you need to consider:

  • The benefit of the feature to end developers
  • The cost of the feature to end developers in terms of time spent understanding it
  • The cost to the language designers in designing and specifying it thoroughly
  • The cost to the compiler writers in implementing it correctly
  • The cost to the test team in testing it thoroughly (in conjunction with everything else around overloading)
  • The cost to future potential features (if this one makes the language more complicated, that leaves less “potentially grokable” additional complexity for other features)

More Related Contents:

  1. How do I use reflection to call a generic method?
  2. Passing arguments to C# generic new() of templated type
  3. What exactly is an “open generic type” in .NET? [duplicate]
  4. Generics in C#, using type of a variable as parameter [duplicate]
  5. Create instance of generic type whose constructor requires a parameter?
  6. Testing if object is of generic type in C#
  7. A generic list of anonymous class
  8. What’s the difference between SortedList and SortedDictionary?
  9. No generic implementation of OrderedDictionary?
  10. Why must I provide explicitly generic parameter types While the compiler should infer the type?
  11. C# Create New T()
  12. Func with out parameter
  13. What does “T” mean in C#?
  14. Why isn’t ArrayList marked [Obsolete]?
  15. Convert string to nullable type (int, double, etc…)
  16. How to initialize a List to a given size (as opposed to capacity)?
  17. Generic Type in constructor
  18. A reusable pattern to convert event into task
  19. Collection of generic types
  20. What does denote in C# [duplicate]
  21. How do I create a generic class from a string in C#? [duplicate]
  22. Parse string to enum type
  23. Wildcard equivalent in C# generics
  24. Ambiguous call between two C# extension generic methods one where T:class and other where T:struct
  25. How do I tell if a type is a “simple” type? i.e. holds a single value
  26. Can I have a variable number of generic parameters?
  27. Returning ‘IList’ vs ‘ICollection’ vs ‘Collection’
  28. Which C# method overload is chosen?
  29. The component does not have a resource identified by the uri
  30. C# generic methods, type parameters in new() constructor constraint

Leave a Comment