3 ms·

Dumb question. Why do reified generics make interop challenging? Or is it reified generics plus value types that don't inherit system.Object? Couldn't the l

Dumb question. Why do reified generics make interop challenging? Or is it reified generics plus value types that don't inherit system.Object? Couldn't the language implementations basically pass around ICollection<Object> in .NET somewhat similar to how they do in Java?

munchbunny 7y ago
The problem is that your GenericClass<T1> and GenericClass<T2> are really more like GenericClass_T1 and GenericClass_T2 with their own distinct type definitions and interfaces. From the perspective of a different runtime/language trying to interop with these types, you have to somehow understand and work with this mapping game. It's much easier from inside the .NET runtime than outside. The general solution is, like you suggested, to avoid using reified generics in the module interface where the interop happens.
- bunderbunder 7y ago
  The solution I remember from the last time I dealt with Python on .NET (which was admittedly a long time ago) was the opposite - you did use the reified generics, and there were facilities to create an instance of GenericClass<TWhatever> from within Python. There's a whole dynamic language runtime that is purpose-built for smoothing over a lot of that stuff. What wouldn't work would be to, e.g., create a Python-native list and try to pass it into a function that expects a .NET IList<T>. Which doesn't feel that odd to me - they may have the same name, but otherwise they're very different types that have very different interfaces. That said, the Iron languages never took off. My personal story there is that all the new dynamic features that C# got with the release of the DLR pretty much killed my desire to interact with C# from a dynamic language. The release that gave me Python on .NET also turned C# itself into an acceptable enough Python for my needs.
pron 7y ago
> Why do reified generics make interop challenging? Suppose you have types A and B, such that A <: B. What is, then, the relationship between List<A> and List<B>? This question is called variance, and different languages have very different answers to this, but once generics are reified, the chosen variance strategy is baked into the runtime. > Couldn't the language implementations basically pass around ICollection<Object> in .NET somewhat similar to how they do in Java? They could, but then this adds significant runtime overhead at the interop layer. For example, a popular standard API may take a parameter of type List<int>. How do you then call it from, say, JavaScript, without an O(n) operation (and without changing JS)?
- deleted 7y ago
  [deleted]
- bunderbunder 7y ago
  > This question is called variance, and different languages have very different answers to this, but once generics are reified, the chosen variance strategy is baked into the runtime. Which, realistically, is probably the only principled way to do things if you want to be doing much with variant generics in a cross-language way. The Java way, "I pick my variance strategy, you pick yours, and we'll both pass everything around as a List<Object> at runtime and just hope that our varying decisions about what their actual contents are allowed to be never cause us any nasty surprises for each other at run time," is not type-safe and can lead to nasty surprises at run time. It's easier, sure, but easier is not necessarily better.
  - pron 7y ago
    Except, realistically, of all the polyglot runtimes, the ones that have good interop erase and the one that doesn't reifies.
noblethrasher 7y ago
.NET Value types do inherit from System.Object. See: https://docs.microsoft.com/en-us/dotnet/api/system.valuetype?view=netframework-4.8 https://docs.microsoft.com/en-us/dotnet/api/system.valuetype...

munchbunny 7y ago

The problem is that your GenericClass<T1> and GenericClass<T2> are really more like GenericClass_T1 and GenericClass_T2 with their own distinct type definitions and interfaces. From the perspective of a different runtime/language trying to interop with these types, you have to somehow understand and work with this mapping game. It's much easier from inside the .NET runtime than outside. The general solution is, like you suggested, to avoid using reified generics in the module interface where the interop happens.

bunderbunder 7y ago
The solution I remember from the last time I dealt with Python on .NET (which was admittedly a long time ago) was the opposite - you did use the reified generics, and there were facilities to create an instance of GenericClass<TWhatever> from within Python. There's a whole dynamic language runtime that is purpose-built for smoothing over a lot of that stuff. What wouldn't work would be to, e.g., create a Python-native list and try to pass it into a function that expects a .NET IList<T>. Which doesn't feel that odd to me - they may have the same name, but otherwise they're very different types that have very different interfaces. That said, the Iron languages never took off. My personal story there is that all the new dynamic features that C# got with the release of the DLR pretty much killed my desire to interact with C# from a dynamic language. The release that gave me Python on .NET also turned C# itself into an acceptable enough Python for my needs.

pron 7y ago

> Why do reified generics make interop challenging? Suppose you have types A and B, such that A <: B. What is, then, the relationship between List<A> and List<B>? This question is called variance, and different languages have very different answers to this, but once generics are reified, the chosen variance strategy is baked into the runtime. > Couldn't the language implementations basically pass around ICollection<Object> in .NET somewhat similar to how they do in Java? They could, but then this adds significant runtime overhead at the interop layer. For example, a popular standard API may take a parameter of type List<int>. How do you then call it from, say, JavaScript, without an O(n) operation (and without changing JS)?

deleted 7y ago
[deleted]
bunderbunder 7y ago
> This question is called variance, and different languages have very different answers to this, but once generics are reified, the chosen variance strategy is baked into the runtime. Which, realistically, is probably the only principled way to do things if you want to be doing much with variant generics in a cross-language way. The Java way, "I pick my variance strategy, you pick yours, and we'll both pass everything around as a List<Object> at runtime and just hope that our varying decisions about what their actual contents are allowed to be never cause us any nasty surprises for each other at run time," is not type-safe and can lead to nasty surprises at run time. It's easier, sure, but easier is not necessarily better.
- pron 7y ago
  Except, realistically, of all the polyglot runtimes, the ones that have good interop erase and the one that doesn't reifies.

noblethrasher 7y ago

.NET Value types do inherit from System.Object. See: https://docs.microsoft.com/en-us/dotnet/api/system.valuetype?view=netframework-4.8 https://docs.microsoft.com/en-us/dotnet/api/system.valuetype...