To get it to understand it’s a type parameter and not a JSX element, you can add a comma after the type parameter: const f = <T1,>(arg1: T1) => <T2,>(arg2: T2) => { return { arg1, arg2 }; }; Or you could use function expressions instead: const f = function<T1>(arg1: T1) { return function<T2>(arg2: T2) … Read more
As of TypeScript 2.3, you can use generic parameter defaults. private logData<T, S = {}>(operation: string, responseData: T, requestData?: S) { // your implementation here }
Similar to David Conrad solution, you can use the full signature as a link description, using syntax: {@link class#method(signature) text-to-display} Remember to escape < and >. For example: {@link #parse(Map, String, String) parse(Map<String, String>, String, String)}
Ok it seems you can do this: Foo<T extends IBar>() { /* */ } And that seems to make all calls require the T to implement IBar.
You can either add a type parameter to your struct, as in Zernike’s answer, or use a trait object. Using the type parameter is better for performance because each value of T will create a specialized copy of the struct, which allows for static dispatch. A trait object uses dynamic dispatch so it lets you … Read more
There is no generic constraint that allows you to enforce operator overload. You may take a look at the following library. Alternatively if you are using .NET 4.0 you could use the dynamic keyword: public static T Add<T>(T number1, T number2) { dynamic a = number1; dynamic b = number2; return a + b; } … Read more
Overloading is typically the bugaboo of type-inferenced languages (at least when, like F#, the type system isn’t powerful enough to contain type-classes). There are a number of choices you have in F#: Use overloading on methods (members of a type), in which case overloading works much like as in other .Net languages (you can ad-hoc … Read more
S <: T means that S is a subtype of T. This is also called an upper type bound. Similarly, S >: T means that S is a supertype of T, a lower type bound. S <% T is a view bound, and expresses that S must come equipped with a view that maps its … Read more
IEnumerable<T> is an interface that is implemented by List<T>. I suspect the reason you’re hearing that IEnumerable<T> should be used is because it’s a less constrictive interface requirement. For example, consider the following method signature: void Output(List<Foo> foos) { foreach(var foo in foos) { /* do something */ } } This method requires that it … Read more
Here’s a complete example: import kotlin.reflect.KClass data class User(val name: String) data class Student(val name: String) fun getUsers(): List<User> = listOf(User(“JB”)) fun getStudents(): List<Student> = listOf(Student(“Claire”)) fun <T: Any> getData(clazz: KClass<T>): List<T>? { return when(clazz) { User::class -> getUsers() as List<T> Student::class -> getStudents() as List<T> else -> null } } fun main(args: Array<String>) { … Read more