I think it refers to open unions, which are types specified with some constructors that might have additional constructors defined later. As you say, Google is curiously reticent, but see, for example, p. 60 of http://www.seas.upenn.edu/~cis500/cis500-f06/ocaml-book.pdf .
OK, fine. Well in Haskell we have Dynamic. Of course matching on a Dynamic may fail, but that's OK because the basis for comparison is untyped languages! Matching on types can always fail there too.
Closed polymorhpism can always be pattern-matched but it requires modifying all matchers. Open polymorphism is the default in OO interfaces: you can always implement a new type by adding code locally.
Since existential types can be monomorphised and compiled to binary code allowing type-safe plugins.
Yeah, I was referring to polymorphism as we have in OO, where old code can call new code.
I didn't even know "closed polymorphism" was a thing (is it equivalent to algebraic types?).
I'm not precise anymore with jargon concerning polymorphism (it's all the same to me), which I probably shouldn't do. I consider two factors: first closed/open (or finite/arbitrary) of 'remembering' an erased type, and second the sugar for nested 'remembering'. Almost all languages have both (open and closed) as either built-in, as a library or as a design pattern for that language. It boils down to either a tagged union or a function pointer. And both can be transformed to the other if needed.
Assembly, C have tagged unions & function pointers.
Java has visitors, instanceOf, reflection.
C++ has visitors, boost::variant, dynamic casts, mach7.
Haskell has ADTs, pattern matching, existential quantification, Dynamic.
Rust has pattern matching, traits, Any.
Python, javascript, lua, lisp are dynamic, it's easy enough to create both.
