As of Go 1.18 you can write a generic function Print as below: package main import ( “fmt” ) // T can be any type func Print[T any](s []T) { for _, v := range s { fmt.Print(v) } } func main() { // Passing list of string works Print([]string{“Hello, “, “world\n”}) // You can … Read more
I must explain to the compiler that B is the same as A::Foo There is a special syntax for it: impl<A, B> Baz<A, B> where A: Generator<Foo = B>, { fn add_foo(&mut self) { self.vec.push(self.generator.generate()); } }
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
This is doable in TypeScript 2.0+. By using an inline { new(): T } type to capture this, you’ll get what you wanted: type Constructor<T> = { new (): T } class BaseModel { static getAll<T>(this: Constructor<T>): T[] { return [] // dummy impl } /** * Example of static method with an argument: */ … Read more
The fact that &’a str does not implement Into<i32> is not taken into account, because there is no guarantee that it couldn’t be added later. This would then break your code. So if this were allowed the possible breakage would make it harder to add implementations to library traits. Unfortunately I couldn’t find documentation for … 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
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
Traits and Traits In Rust, you can use trait to define an interface comprised of: associated types, associated constants, associated functions. and you can use traits either: as compile-time bounds for generic parameters as types, behind references or pointers. However… only some traits can be used directly as types. Those traits that do are labeled … Read more
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
While generic types can seem to “infect” the rest of your code, that’s exactly why they are beneficial! The compiler knowledge about how big and specifically what type is used allow it to make better optimization decisions. That being said, it can be annoying! If you have a small number of types that implement your … Read more