I have the feeling that what you actually want is that T should be able to copy itself with a new ID, and have an ID. Not necessarily that it is a data class. So you could just use an interface to define that. For example: interface CopyableWithId<out T> where T: CopyableWithId<T> { fun copy(newId: … Read more
The T type isn’t defined yet. It needs to be added to the method as a type variable like: filterUnique<T>(array: Array<T>): Array<T>; Or added to the interface like: export interface IGenericServices<T> { filterUnique(array: Array<T>): Array<T>; }
Your argument is flawed. Kotlin has not been released yet*, and Ceylon just had its first version released, and I’ll quote one of the things it is missing from their announcement: reified generics So, excuse me, but what implementation proves it is possible? In fact, I haven’t looked much at what Kotlin is promising, but … Read more
Due to type erasure, actual generic arguments cannot be obtained through T::class token of a generic class. Different objects of a class must have the same class token, that’s why it cannot contain actual generic arguments. Edit: Since Kotlin 1.3.50, following the technique described below to get type information for a reified type parameter is … Read more
Due to generic type erasure List class has a single implementation for all its generic instantiations. You can only get a class corresponding to List<*> type, and thus create only Builder<List<*>>. That builder instance is suitable for building a list of something. And again due to type erasure what that something is you can decide … Read more
Change your type to indicate it is not-nullable and it should work. You can do this by indicating that T needs to extend Any (rather than Any?). fun <T : Any> test(t: T) { t::class }
Edit: Sorry for the premature answer, it actually doesn’t work, because the compiler will choose the function for different types when called from within another function: func foobar<T,U> (lhs: Foo<T>, rhs: Foo<U>) -> Bool { return lhs.sameType(rhs) } If you stay in pure Swift territory, the following will work: Given a simple generic struct struct … Read more
Yes, you’re missing an important detail of generics implementation on JVM: the type erasure. In a nutshell, the compiled bytecode of classes doesn’t actually contain any information about generic types (except for some metadata about the fact that a class or a method is generic). All the type checking happens at compile time, and after … Read more
Rust 1.26 fn filter_one(input: &[u8]) -> impl Iterator<Item = &u8> { input.iter().filter(|&&x| x == 1) } fn main() { let nums = vec![1, 2, 3, 1, 2, 3]; let other: Vec<_> = filter_one(&nums).collect(); println!(“{:?}”, other); } Rust 1.0 fn filter_one<‘a>(input: &’a [u8]) -> Box<Iterator<Item = &’a u8> + ‘a> { Box::new(input.iter().filter(|&&x| x == 1)) } … Read more
Let’s break down your example a bit: fn cube<T: Mul>(x: T) -> T { let a = x * x; let b = a * x; b } What are the types of a and b? In this case, the type of a is <T as std::ops::Mul>::Output — sound familiar from the error message? Then, … Read more