While the type parameters of a generic method can be restricted by bounds, such as extends Foo & Bar, they are ultimately decided by the caller. When you call getFooBar(), the call site already knows what T is being resolved to. Often, these type parameters will be inferred by the compiler, which is why you … Read more
EDIT – apologies, I only just noticed your first error. There is no way of instantiating a T at runtime because the type information is lost when your program is compiled (via type erasure) You will have to pass in some factory to achieve the construction: class BalanceActor[T <: Actor](val fac: () => T) extends … Read more
Since the actual type T is available to you only through reflection, you would need to access methods of Store<T> through reflection as well: Type constructedType = classType.MakeGenericType(typeParams); object x = Activator.CreateInstance(constructedType, new object[] { someParameter }); var method = constructedType.GetMethod(“MyMethodTakingT”); var res = method.Invoke(x, new object[] {someObjectThatImplementsStorable}); EDIT You could also define an additional … Read more
No – there’s no such concept either in C# or in the CLR.
At a casual glance, it appears that this should (as in beer should be free) work. However, a quick sanity check shows us why it can’t. Bear in mind that the following code will not compile. It’s intended to show why it isn’t allowed to, even though it looks alright up until a point. public … Read more
Yes, this can be done (sort of; see below). (In the C++ world, this is called the “Curiously Recurring Template Pattern“, but it applies in Java too): public interface Recur<T extends Recur<T>> { // … } (Note the second mention of T. That’s an essential part of the CRTP.) Also, this is how java.util.Enum is … Read more
Though maps and slices in go are generic themselves, they are not covariant (nor could they be, since interfaces aren’t generics). It’s part of working with a language that doesn’t have generics, you will have to repeat some things. If you really just need to get the keys of any old map, you can use … Read more
All member fields of an interface are by default public, static and final. Since inner interface is static by default, you can’t refer to T from static fields or methods. Because T is actually associated with an instance of a class, if it were associated with a static field or method which is associated with … Read more
This can be accomplished easily using the curiously recurring template pattern class BaseClass<T> where T : BaseClass<T> { static void SomeMethod() { var t = typeof(T); // gets type of derived class } } class DerivedClass : BaseClass<DerivedClass> {} call the method: DerivedClass.SomeMethod(); This solution adds a small amount of boilerplate overhead because you have … Read more
Here’s a summary of the three: List: A list with no type parameter. It is a list whose elements are of any type — the elements may be of different types. List<?>: A list with an unbounded type parameter. Its elements are of a specific, but unknown, type; the elements must all be instances of … Read more