An “enumeration with associated value” might be what you are looking for: enum StringOrInt { case string(String) case int(Int) } You can either assign a string or an integer: var value: StringOrInt value = .string(“Hello”) // … value = .int(123) Retrieving the contents is done with a switch-statement: switch value { case .string(let s): print(“String:”, … Read more
There are two distinct flavors of generics in TypeScript: generic functions and generic types. A generic function declares its generic type parameter (or parameters) on the call signature of the function: type IdentityGenFunc = <T>(t: T) => T The type parameter on a generic function (T above) isn’t specified until the function is actually called, … Read more
Instead of using Self or A in each of the initialisers, you can simply override each subclass’ initialiser to use its own type as operation. This works because A‘s initialiser states that operation should be a type that conforms to A, and when you override it you have the liberty to use a subclass of … Read more
Yes, it’s possible. The trick is to start from a pointer to the type (whose value can be a typed nil, that’s perfectly OK), and then use Type.Elem() to get the reflect.Type descriptor of the pointed type (the base type). See some examples: t := reflect.TypeOf((*int)(nil)).Elem() fmt.Println(t) t = reflect.TypeOf((*http.Request)(nil)).Elem() fmt.Println(t) t = reflect.TypeOf((*os.File)(nil)).Elem() fmt.Println(t) … Read more
See this scala-debate thread for a discussion of what’s going on here. The problem is that Scala’s type inference happens per parameter list, not per parameter. As Josh Suereth notes in that thread, there’s a good reason for the current approach. If Scala had per-parameter type inference, the compiler couldn’t infer an upper bound across … Read more
The advantage would come when it looks something like this: trait Container[A <: Container[A]] extends Ordered[A] { def clone: A def pair: (A, A) = (clone, clone) } class MyContainer extends Container[MyContainer] { def clone = new MyContainer } Now you get pair for free, and you get the correct return type. Without something like … Read more
The ISO C11 standard states in 6.2.5 Types: There are five standard signed integer types, designated as signed char, short int, int, long int, and long long int. For each of the signed integer types, there is a corresponding (but different) unsigned integer type (designated with the keyword unsigned) that uses the same amount of … Read more
numeric is exact! Unlike claimed by another answer, numeric is not a floating-point type, but an arbitrary precision type as defined by the SQL standard. Storage is exact. I quote the manual: The type numeric can store numbers with a very large number of digits and perform calculations exactly. It is especially recommended for storing … Read more
MakeGenericType – i.e. Type passInType = … /// perhaps myAssembly.GetType( “ConsoleApplication2.Program+Person”) Type t = typeof(List<>).MakeGenericType(passInType); For a complete example: using System; using System.Collections.Generic; using System.Reflection; namespace ConsoleApplication2 { class Program { class Person {} static void Main(){ Assembly myAssembly = typeof(Program).Assembly; Type passInType = myAssembly.GetType( “ConsoleApplication2.Program+Person”); Type t = typeof(List<>).MakeGenericType(passInType); } } } As suggested … Read more
In specific cases you could always do like std::make_pair: template<class T> make_foo(T val) { return foo<T>(val); } EDIT: I just found the following in “The C++ Programming Language, Third Edition”, page 335. Bjarne says: Note that class template arguments are never deduced. The reason is that the flexibility provided by several constructors for a class … Read more