Which language futures make D overcompicated?

[Nick Sabalausky (Abscissa)]

On 02/10/2018 07:35 AM, Timon Gehr wrote:
> 
> TL;DR: Parametrically polymorphic functions have /runtime/ type 
> parameters. inout can be interpreted as a dependent function of type 
> "{type y | y.among(x, const(x), immutable(x)) } delegate(type x)" and an 
> inout function can be thought of as a function that takes inout as an 
> argument and produces the function as the return value. This formulation 
> is more powerful than what the inout syntax can capture, and this is 
> what causes problems with type safety. In particular, 'inout' does not 
> support proper lexical scoping.
> 
> TS;NM: https://gist.github.com/tgehr/769ac267d76b74109a195334ddae01c3 
> (Some version of this was originally intended to go to the D blog, but I 
> wanted to wait until inout has an obviously type safe definition. It 
> also highlights other inout issues than just type unsafety and shows how 
> all of them might be fixed in principle by adding polymorphism.)
> 
> ---
> 
> I'll first explain parametric polymorphism, and then what the inout 
> problem is.
> 

Ahh, thanks. I'm still not *completely* 100%, but those explanations 
definitely helped a lot. Very insightful.

Side questions:

- Does this mean that fixing the issues with inout (even if done via 
some replacement of inout) would necessarily involve some runtime 
processing in at least certain cases?

- Though I realize this may contradict the definition of "parametric 
polymorphism" as you've described (and also ignoring the matter of 
virtual functions): Would it be theoretically possible to have 
parametric polymorphism that's *implemented* entirely via compile-time 
mechanisms such as templates? Or does our template system as D has it 
already represent the fundamental limits of such an approach?

Incidentally, I've felt for a long while it would've been really nice if 
D had first-class types (for both runtime and compile time). I think a 
system like that, if done right, could have gone a long way to 
alleviating all the awkwardness and asymmetries of reflection and type 
handling in D. It's also why I can understand people coming from certain 
dynamic languages who may find our metaprogramming combersome.