On: Learning Common Lisp to beat Java and Rust on a phone encoding problem

[xondono]

Just because someone else asked:

here's the Rust code: fn fib(n: usize) -> u64 { match n { 0 => 1, 1 => 1, _ => fib(n - 1) + fib(n - 2), } }

  fn main() {
    println!("{}", fib(50));
  }

Here's the Lisp code:

  (defun fib (n)
  "Return the nth Fibonacci number."
  (if (< n 2)
        n
        (+ (fib (- n 1))
           (fib (- n 2)))))

Again, I'm not trying to benchmark the languages, I'm not interested in this language drag racing competition/flamewar, I don't care about how performant a language is in the end. I care about how fast a language is for unit of time I spent. This metric is obviously only useful to me, because if you know a lot of Lisp but little Rust, your time spent will be very different.

I also know the Rust snippet will crash at fib(~100), and that I could write the thing in a loop and get there under 1ms. The same is surely true about Lisp.

[randomswede → xondono]

Once you exceed the size of a fixnum (this depends on the implementation), Common Lisp will silently spill to bignums (since you have not declared your variable to be a fixnum; you could declare it as an integer and still get the fixnum->bignum spill).