New programming paradigm

[Paul Backus]

On Monday, 4 September 2017 at 03:26:23 UTC, EntangledQuanta 
wrote:
> Take a variant type. It contains the "type" and the data. To 
> simplify, we will treat look at it like
>
> (pseudo-code, use your brain)
>
> enum Type { int, float }
>
> foo(void* Data, Type type);
>
> The normal way to deal with this is a switch:
>
> switch(type)
> {
>     case int: auto val = *(cast(int*)Data);
>     case float: auto val = *(cast(float*)Data);
> }
>
>
> But what if the switch could be generated for us?
>
> [...]
>
> But, in fact, since we can specialize on the type we don't have 
> to use switch and in some cases do not even need to specialize:
>
> for example:
>
> foo(T)(T* Data) { writeln(*Data); }
>
> is a compile time template that is called with the correct type 
> value at run-time due to the "magic" which I have yet to 
> introduce.
>
> Note that if we just use a standard runtime variant, writeln 
> would see a variant, not the correct type that Data really is. 
> This is the key difference and what makes this "technique" 
> valuable. We can treat our dynamic variables as compile time 
> types(use the compile time system) without much hassle. They 
> fit naturally in it and we do not clutter our code switches. We 
> can have a true auto/var like C# without the overhead of the 
> IR. The cost, of course, is that switches are still used, they 
> are generated behind the scenes though and the runtime cost is 
> a few instructions that all switches have and that we cannot 
> avoid.
>
> To get a feel for what this new way of dealing with dynamic 
> types might look like:
>
> void foo(var y) { writeln(y); }
>
> var x = "3"; // or possibly var!(string, int) for the explicit 
> types used
> foo(x);
> x = 3;
> foo(x);

It sounds like what you are describing is a sum type. There is an 
implementation of one in the standard library, 
std.variant.Algebraic, as well as several alternative 
implementations on code.dlang.org, including my own, "sumtype" 
[1].

Using sumtype, your example would look like this:

alias Var = SumType!(string, int);

void foo(Var y) {
     var.match!(
         (value) { writeln(value); } // template lambda
     );
}

Var x = "3";
foo(x);
x = 3;
foo(x);

The match method takes a list of functions as template arguments, 
and generates a switch statement that maps each possible type of 
Var to one of those functions. All type checking is done at 
compile time.

[1] https://code.dlang.org/packages/sumtype