Fact checking for my talk

[Ethan Watson via Digitalmars-d]

So I fly to Cologne tomorrow morning, and will be presenting on 
Tuesday. Got my talk written, gave it a dry run at the office and 
got feedback on it. Seems to be in a good spot.

But before I go up and feature compare to other languages, it'll 
be a good idea to get my facts right.

There's three spots in my talk where I go through some D code, 
and then show a table indicating whether the features I used in 
those examples are available in other, trendier languages. In 
some cases, the features become available with after-market add 
ons. But I'm focusing exclusively on stuff you can get out of the 
box, ie write some code and compile it with a stock 
DMD/LDC/GDC/SDC install and it'll Just Work(TM).

So here's a dodgy table indicating the features I'm showing on 
the slides, and the languages that are most relevant to game 
developers - C# and Swift - with Rust thrown in since that's the 
new language everyone knows about.

If I've got something wrong with the out-of-the-box solution, 
please let me know. If there is something you can do with an 
add-on, also let me know since it will allow me to prepare for 
the inevitable audience questions saying "but you can do this 
with this etc etc"


                              |  Rust   |  Swift  |    C#   |
-----------------------------|---------+---------+---------|
     Template Constraints     |    Y    |    Y    |  where  | [1]
-----------------------------|---------+---------+---------|
   Template "if" Constraints  |  where  |  where  |  where  |
-----------------------------|---------+---------+---------|
         static if            |    N    |    N    |    N    |
-----------------------------|---------+---------+---------|
      Eponymous templates     |    N    |    N    |    N    |
-----------------------------|---------+---------+---------|
    Compile time reflection   |    N    |    N    |    N    |
-----------------------------|---------+---------+---------|
             CTFE             |    N    |    N    |    N    |
-----------------------------|---------+---------+---------|
    User defined attributes   |  Crates | Runtime |    Y    |
-----------------------------|---------+---------+---------|
    Deep function inspection  |    N    |    N    |    N    |
-----------------------------|---------+---------+---------|
            Mixins            |    N    |    N    |    N*   | [2]
-----------------------------|---------+---------+---------|

[1] Limited comparisons can be made with template where 
constraints
[2] Mixins in swift are essentially traits and protocol 
extentions, not like D mixins at all