├── README.md
└── src
    ├── bench1.go
    ├── bench1.js
    ├── bench1.rs
    ├── bench1.swift
    ├── fib.go
    ├── fib.js
    ├── fib.rs
    ├── fib.swift
    └── main.rs


/README.md:
--------------------------------------------------------------------------------
1 | ## Go vs Rust vs Swift vs Node
2 | 
3 | Very very simple benchmarks among the new user friendly typed languages.
4 | The same code looks almost the same in every language, no particular optimizations.
5 | 
6 | Post & results: https://grigio.org/go-vs-node-vs-rust-vs-swift/
7 | 


--------------------------------------------------------------------------------
/src/bench1.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | import "fmt"
 3 | 
 4 | var iter = 10000000
 5 | var sum = 0
 6 | 
 7 | var x[]int;
 8 | var y[]int;
 9 | 
10 | func main() {
11 | 
12 |   for i:=0; i<iter; i++ {
13 |     x = append(x, i)
14 |     y = append(y, i + 1)
15 |   }
16 | 
17 |   for i:=0; i<iter; i++ {
18 |     if i % 5 == 0 && x[i] % 2 == 0 {
19 |       sum += x[i]
20 |     }
21 |   }
22 | 
23 |   for i:=0; i<iter; i++ {
24 |     if i % 5 == 0 && y[i] % 2 == 0 {
25 |       sum += y[i]
26 |     }
27 |   }
28 | 
29 |   fmt.Print(sum)
30 | }
31 | 


--------------------------------------------------------------------------------
/src/bench1.js:
--------------------------------------------------------------------------------
 1 | var iter = 10000000;
 2 | var sum = 0;
 3 | 
 4 | var x = [];
 5 | var y = [];
 6 | 
 7 | for (var i=0; i<iter; i++) {
 8 |   x.push(i)
 9 |   y.push(i + 1)
10 | }
11 | 
12 | for (var i=0; i<iter; i++) {
13 |   if (i % 5 === 0 && x[i] % 2 === 0) {
14 |     sum += x[i];
15 |   }
16 | }
17 | 
18 | for (var i=0; i<iter; i++) {
19 |   if (i % 5 === 0 && y[i] % 2 === 0) {
20 |     sum += y[i];
21 |   }
22 | }
23 | 
24 | console.log(sum)
25 | 


--------------------------------------------------------------------------------
/src/bench1.rs:
--------------------------------------------------------------------------------
 1 | fn main() {
 2 |     let iter = 10000000;
 3 |     let mut sum = 0;
 4 | 
 5 |     let mut x: Vec<i64> = Vec::new();
 6 |     let mut y: Vec<i64> = Vec::new();
 7 | 
 8 |     for i in 0..iter {
 9 |       x.push(i);
10 |       y.push(i + 1);
11 |     }
12 | 
13 |     for i in 0..iter {
14 |       if i % 5 == 0 && x[i as usize] % 2 == 0 {
15 |         sum += x[i as usize]
16 |       }
17 |     }
18 | 
19 |     for i in 0..iter {
20 |       if i % 5 == 0 && y[i as usize] % 2 == 0 {
21 |         sum += y[i as usize]
22 |       }
23 |     }
24 | 
25 |     println!("{}",sum);
26 | }
27 | 


--------------------------------------------------------------------------------
/src/bench1.swift:
--------------------------------------------------------------------------------
 1 | var iter = 10000000;
 2 | var sum = 0;
 3 | 
 4 | var x: Array<Int> = [];
 5 | var y: Array<Int> = [];
 6 | 
 7 | for (var i=0; i<iter; i++) {
 8 |   x.append(i)
 9 |   y.append(i + 1)
10 | }
11 | 
12 | for (var i=0; i<iter; i++) {
13 |   if (i % 5 == 0 && x[i] % 2 == 0) {
14 |     sum += x[i];
15 |   }
16 | }
17 | 
18 | for (var i=0; i<iter; i++) {
19 |   if (i % 5 == 0 && y[i] % 2 == 0) {
20 |     sum += y[i];
21 |   }
22 | }
23 | 
24 | print(sum)
25 | 


--------------------------------------------------------------------------------
/src/fib.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | import "fmt"
 3 | 
 4 | var num = 45
 5 | 
 6 | func fib(n int) int {
 7 | 	if n <= 2 {
 8 | 		return 1;
 9 | 	} else {
10 | 		return fib(n - 1) + fib(n - 2)
11 | 	}
12 | }
13 | 
14 | func main() {
15 | 	fmt.Println(fib(num))
16 | }
17 | 


--------------------------------------------------------------------------------
/src/fib.js:
--------------------------------------------------------------------------------
1 | var num = 45;
2 | var fib = function(n) {
3 |   return (n <= 2) ? 1 :
4 |     fib(n - 1) + fib(n - 2);
5 | }
6 | 
7 | console.log(fib(num));
8 | 


--------------------------------------------------------------------------------
/src/fib.rs:
--------------------------------------------------------------------------------
 1 | fn fib(n: i64) -> i64 {
 2 |     if n <= 2 {
 3 |         1
 4 |     } else {
 5 |         fib(n - 1) + fib(n - 2)
 6 |     }
 7 | }
 8 | 
 9 | fn main() {
10 |     let num = 45;
11 |     println!("{}", fib(num))
12 | }
13 | 


--------------------------------------------------------------------------------
/src/fib.swift:
--------------------------------------------------------------------------------
 1 | func fib(n: Int) -> Int {
 2 |     if n <= 2 {
 3 |         return 1
 4 |     } else {
 5 |         return (fib(n - 1) + fib(n - 2))
 6 |     }
 7 | }
 8 | 
 9 | let num = 45
10 | print(fib(num))
11 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | #[macro_use]
 2 | extern crate async_await;
 3 | 
 4 | use async_await::*;
 5 | 
 6 | fn fib(n: i32) -> i32 {
 7 |     if n <= 2 {
 8 |         1
 9 |     } else {
10 |         fib(n - 1) + fib(n - 2)
11 |     }
12 | }
13 | 
14 | fn main() {
15 |     let computation1 = async!{fib(43)};
16 |     let computation2 = async!{fib(45)};
17 |     let res1 = await!(computation1);
18 |     let res2 = await!(computation2);
19 | 
20 |     println!("{}", res1);
21 |     println!("{}", res2);
22 |     println!("{}",  res1+res2);
23 | }
24 | 


--------------------------------------------------------------------------------