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()); } }
You can implement a custom JsonDeserializer for your generic type which also implements ContextualDeserializer. For example, suppose we have the following simple wrapper type that contains a generic value: public static class Wrapper<T> { public T value; } We now want to deserialize JSON that looks like this: { “name”: “Alice”, “age”: 37 } into … Read more
No, you can’t declare generic operators in C#. Operators and inheritance don’t really mix well. If you want Foo + Foo to return a Foo and Bar + Bar to return a Bar, you will need to define one operator on each class. But, since operators are static, you won’t get the benefits of polymorphism … Read more
// #1 (does compile) List raw = null; List<?> wild = raw; // #2 (doesn’t compile) List<List> raw = null; List<List<?>> wild = raw; First let’s sort out why these are actually unrelated assignments. That is, they’re governed by different rules. #1 is called an unchecked conversion: There is an unchecked conversion from the raw … Read more
This is deliberate. Static classes try to prevent inappropriate use, so in almost all situations, you can’t use them in situations where you’d normally want an instance of the type… and that includes type arguments. See section “Static classes” of the C# 6 spec for the very limited set of situations in which you can … 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
This question suits one of my old notes. I hope this illustration helps:
The signature of fooMethod(Class<?>) is the same as the signature of fooMethod(Class) after erasure, since the erasure of Class<?> is simply Class (JLS 4.6). Hence, fooMethod(Class) is a subsignature of the fooMethod(Class<?>) but not the opposite (JLS 8.4.2). For overriding with instance methods you need the overriding method to be a subsignature of the overridden … 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
You can do something like this in a header file: // // generic.h // #define TOKENPASTE(x, y) x ## y #define GET_MINIMUM(T) TOKENPASTE(get_minimum_, T) TYPE GET_MINIMUM (TYPE) (TYPE * nums, size_t len){ TYPE min = nums[0]; for (size_t i = 1; i < len; i++) { if (nums[i] < min) { min = nums[i]; } … Read more