type-erasure - w3toppers.com

What is type erasure in C++?

Here’s a very simple example of type erasure in action: // Type erasure side of things class TypeErasedHolder { struct TypeKeeperBase { virtual ~TypeKeeperBase() {} }; template <class ErasedType> struct TypeKeeper : TypeKeeperBase { ErasedType storedObject; TypeKeeper(ErasedType&& object) : storedObject(std::move(object)) {} }; std::unique_ptr<TypeKeeperBase> held; public: template <class ErasedType> TypeErasedHolder(ErasedType objectToStore) : held(new TypeKeeper<ErasedType>(std::move(objectToStore))) {} }; … Read more

Type erasure in C++: how boost::shared_ptr and boost::function work?

The idea is simple, you define a base class that has an interface with the functionality you need, and then inherit from it. Since the type erased class uses only that interface, the actual type underneath is forgotten and erased. Alternatively, if the only needed interface can be expressed as free functions you can store … Read more

Java: getClass() of bounded type

If getClass() returns Class<? extends X>, nothing really bad can happen; actually it’ll help a lot of use cases. The only problem is, it is not theoretically correct. if an object is an ArrayList<String>, its class cannot be Class<ArrayList<String>> – there is no such class, there is only a Class<ArrayList>. This is actually not related … Read more

Type erasure, overriding and generics

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

Scala double definition (2 methods have the same type erasure)

I like Michael Krämer’s idea to use implicits, but I think it can be applied more directly: case class IntList(list: List[Int]) case class StringList(list: List[String]) implicit def il(list: List[Int]) = IntList(list) implicit def sl(list: List[String]) = StringList(list) def foo(i: IntList) { println(“Int: ” + i.list)} def foo(s: StringList) { println(“String: ” + s.list)} I think … Read more

What are the benefits of Java’s types erasure?

Type Erasure Is Good Let’s stick to the facts A lot of the answers thus far are overly concerned with the Twitter user. It’s helpful to keep focused on the messages and not the messenger. There is a fairly consistent message with even just the excerpts mentioned thus far: It’s funny when Java users complain … Read more

Class is a raw type. References to generic type Class should be parameterized

The interface declares the method with a raw type. In that case, you can’t override it nicely without having the warning. The origin of your problem is that the Spring interface was declared to be Java 1.4 compliant. Note that Spring 3.0 is supposed to deliver all classes as Java 1.5 compliant, so that would … Read more

Java erasure with generic overloading (not overriding)

Either rename the methods, or use polymorphism: use an interface, and then either put the clawback code in the objects themselves, or use double-dispatch (depending on your design paradigm and taste). With code in objects that would be: public interface Clawbackable{ void clawBack() } public class CommissionFacade { public <T extends Clawbackable> void clawBack(Collection<T> objects) … Read more

Type erasing type erasure, `any` questions?

This is a solution that uses C++14 and boost::any, as I don’t have a C++17 compiler. The syntax we end up with is: const auto print = make_any_method<void(std::ostream&)>([](auto&& p, std::ostream& t){ t << p << “\n”; }); super_any<decltype(print)> a = 7; (a->*print)(std::cout); which is almost optimal. With what I believe to be simple C++17 changes, … Read more

How to pattern match on generic type in Scala?

Maybe this will help def matchContainer[A: Manifest](c: Container[A]) = c match { case c: Container[String] if manifest <:< manifest[String] => println(c.value.toUpperCase) case c: Container[Double] if manifest <:< manifest[Double] => println(math.sqrt(c.value)) case c: Container[_] => println(“other”) } Edit: As Impredicative pointed out, Manifest is deprecated. Instead you could do the following: import reflect.runtime.universe._ def matchContainer[A: TypeTag](c: … Read more