Re: Nim vs D

[aedt]

This is very interesting. I am a big fan of D, and I use D as my to-go 
language. I like Nim too. But how come the difference between D, C++ and Nim be 
so big? This is impressive and it's a little bit too good to be true! In my 
machine,
    
    
    //D
    import std.conv, std.stdio;
    
    void main()
    {
        fibonacci(50).writeln;
    }
    
    float fibonacci(int n)
    {
        if (n < 2)
            return n.to!float;
        else
            return fibonacci(n-1) + fibonacci(n-2);
    }
    

LDC/D with 
    
    
    -release -O4

takes 76.9s
    
    
    //C++
    #include <iostream>
    
    using namespace std;
    
    float fib(int x) {
        if (x < 2)
            return float(x);
        else
            return fib(x-1)+fib(x-2);
    }
    
    
    int main() {
        cout << fib(50) << endl;
    }
    

GCC/C++ with 
    
    
    -O3

takes 39.9s
    
    
    //Rust
    fn main(){
        println!("{}", fib(50));
    }
    
    fn fib(n: i32) -> f32 {
        if n < 2 {
            return n as f32;
        } else {
            return fib(n-1) + fib(n-2);
        }
    }
    

Rust's release build takes 80.13s.
    
    
    //C
    #include <stdio.h>
    
    float fibonacci(int n)
    {
        if (n < 2)
            return (float)n;
        else
            return fibonacci(n-1) + fibonacci(n-2);
    }
    
    int main()
    {
        printf("%f", fibonacci(50));
        return 0;
    }
    

GCC/C with 
    
    
    -O3

takes 40.5s

And 
    
    
    #Nim
    proc fibonacci(n: int): float =
      if n < 2:
        result = float(n)
      else:
        result = fibonacci(n-1) + fibonacci(n-2)
    
    echo fibonacci(50)
    

Nim's release build takes 5.6s only! What optimization took place in the Nim 
build?