
Type Erasure with Merged Concepts in C++ - adamnemecek
http://aherrmann.github.io/programming/2014/10/19/type-erasure-with-merged-concepts/
======
jonsterling
I am very confused by the definition of type erasure which is being used in
this work.

As a type theorist, my working definition is "terms which have types inside
them are turned into terms which do not have types inside them"; this is a
process which occurs after types have been checked/inferred, and before
execution. This is crucially _not_ something that programmers do: if you take
a polymorphic interface and wrap it up in one that doesn't quantify over
types, that wasn't type erasure.

But perhaps I have simply misunderstood the code in this post; I'll admit it's
been a while since I have read C++.

~~~
subb
When I frist saw the title of Zach Laine's talk, I was confused too. Type
erasure for me is what happens with generics in Java, i.e. type information is
discarded after compilation. In this case, the type is still present at
runtime. I saw this technique described as "type safe void*", which is
paradoxal to me. However, I do get the idea behind this, but I think "type
erasure" is a wrong name for it.

~~~
jonsterling
Yes, I think this stuff has nothing to do at all with type erasure. it's very
confusing when a well defined concept gets appropriated for something that is
very different, and totally unrelated.

~~~
Sharlin
Not sure about its exact origins, but in the C++ context the usage is pretty
well established. AFAIK it was first used to denote the way std::function
(then boost::function) is able to hide the actual type of a callable object
while retaining type safety.

------
fish2000
This is pretty awesome – I’m writing a Python extension in C++ that piggybacks
on top of NumPy dtype codes, and I _thought_ that I could “just” use templates
to deal with dynamic typing. It proved to be waaaay less straightforward than
that, and I had to hack through a lot of stuff with cumbersome macros, and
wound up with a gigantic binary image as a result. Actually doing type erasure
in C++ (which type erasure, as I understand, is like de rigueur in Java) cuts
through all of that cruft… and so, to the refactormobile! Yes.

~~~
infinite8s
Care to blog about your refactor? I can sort of see how you could use type
erasure combined with numpy dtypes but it would be great to see a concrete
example.

------
vikiomega9
Noob question here. In a dynamic language, say python, would duck typing solve
the greet_tom problem described here?

~~~
sonyandy
In C++, duck typing (structural typing) could be represented explicitly using
type erasure (explicit in how you have to declare what the structure is) or
using templates, which do not require declaration of the structure beyond the
actual use in code (though concepts allow you provide structure requirements).
Templates result in code being generated for each set of template arguments
used. Type erasure does not - or at least not nearly as much (the constructors
of the type-erased type almost certainly use templates). In this way, the type
erasure approach most closely resembles the behavior of Python (virtual
calls), while the template approach most closely resembles the style of Python
(no declaration of structure required). There is no ideal way to get both the
behavior and style of Python, but you can get pretty close by passing only one
type of type-erased type to a function template - only one template function
will be produced, which would make calls to virtual functions.

~~~
vikiomega9
Amazing, advanced C++ is simply beautiful :P It is very interesting to learn
about the hoops static type checking has to jump through.

