Jonathan50 wrote:

With lazy evaluation you can have circular data structures without mutation. (And lazy evaluation messes up imperative code anyway, so you can't/shouldn't mutate objects to make circular data structures.)

bharvey wrote:

Jonathan50 wrote:

With lazy evaluation you can have circular data structures without mutation. (And lazy evaluation messes up imperative code anyway, so you can't/shouldn't mutate objects to make circular data structures.)

It's not just circular structures.

bharvey wrote:

Hardmath123 wrote:

def fib(n):
    return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1)

You're being sarcastic, right? It gives me a headache. I don't even want to think about convincing myself it can work.

Hardmath123 wrote:

It's based on generating functions; imagine a power series P such the coefficient of x^n is the nth Fibonacci number.

bharvey wrote:

-ScratchOs wrote:

I was just wondering, how do you implement the wait()secs in JS?
(is it a loop or a setTimeout …)

Certainly not a loop; when one script is waiting, the rest of the program and the IDE still have work to do. For the same reason, it's not a setTimeout either. Snap! includes its own scheduler that runs scripts in rotation. The wait block remembers when it started, and every time the scheduler gets to it, it sees whether enough time has passed. If not, it just yields and the scheduler runs the next thread:

Process.prototype.doWait = function (secs) {
    if (!this.context.startTime) {
        this.context.startTime = Date.now();
    }
    if ((Date.now() - this.context.startTime) >= (secs * 1000)) {
        return null;
    }
    this.pushContext('doYield');
    this.pushContext();
};

Jonathan50 wrote:

Why would anyone use

function fib(n) {
  var a = 1;
  var b = 0;
  while(n > 1) {
    n--;
    var temp = a;
    a += b;
    b = temp;
  }
  return a;
}

when you can use

function fib(n) {
  return n <= 2 ? 1
                : fib(n - 1) + fib(n - 2);
}

?

And tail recursion is better than looping because loops are imperative. For a while loop to terminate there needs to be state.
And you don't need ugly ‘temp’ variables for a tail recursive version!

def fib(n):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a + b
    return b

def fib_iter():
    a, b = 0, 1
    while True:
        yield b
        a, b = b, a + b

bharvey wrote:

The iterative code for Euclid's GCD algorithm, for example, is almost identical to the iterative code for Fib

BookOwl wrote:

@bharvey, you forgot the fact that fib(n) = fib(n-1)+fib(n-2) is not tail recursive, so even in Scheme you won't be able to calculate large Fibonacci numbers.

Maybe this means that they are related somehow…

bharvey wrote:

Okay, here's my candidate for most elegant efficient implementation:

(define fib-stream
   (cons-stream 0
                (cons-stream 1
                             (stream-map + fib-stream
                                           (stream-cdr fib-stream)))))
(define (fib n) (stream-ref fib-stream n))

BookOwl wrote:

Project loading really needs to be made async. Every time I try to load a block library or project, my web browser says that snap! is locked up, and if I let it continue, it locks up my whole browser for one or two minutes, depending on how big the project is.

joefarebrother wrote:

I fixed my try/catch block!

;; Doesn't implement all stream functionality (most notably, finite streams)