Question

I’ll use this simple maze-solver program written in C for example of what i need in javascript:

int is_free_place(int x,int y) {
 char ch[2];
 if(x<1||x>80||y<1||y>20)
  return 0;
 gettext(x,y,x,y,ch);
 return ch[0]==32; // X or space
}
int solve(int x, int y, int x_end,int y_end) {
 int ans=0;
 if(kbhit()) efn();
 gotoxy(x,y);
 putchar('.');
 delay(DELAY_TIME);
 if(x==x_end&&y==y_end)
  return 1;
 if(is_free_place(x-1,y))
  ans=solve(x-1,y,x_end,y_end);      //// <<<<< recursion starts here
 if(ans==0&&is_free_place(x+1,y))    //// can't continue to here if using setTimeout
  ans=solve(x+1,y,x_end,y_end);      //// because ans is not set
 if(ans==0&&is_free_place(x,y-1))
  ans=solve(x,y-1,x_end,y_end);
 if(ans==0&&is_free_place(x,y+1))
  ans=solve(x,y+1,x_end,y_end);
 if(ans==0){
  gotoxy(x,y);
  putchar(' ');
  delay(DELAY_TIME);
 }
 return ans;
}
void main(){
 clrscr();
 efn(); // reads maze from file, shows menu, calls solve()
}

I’m trying to do a similar recursion in javascript, but the browser freezes until the code is done and what i need is a slow animation of the progress with the option to pause and change stuff. So i tried using setTimeout, but i can’t figure out the algorithm for when the function “returns” and code continues from the recursion call…
(setTimeout continues right away and does not wait for function return )

[update]
is there a way to do this using yield, and not using stack?

Answer 1

It’s going to be a bit non-trivial to write this as something you can use with setTimeout, especially since, as written, you need to get the result of your recursive invocations. I think the easiest way to handle something like this is would have to use some sort of promise infrastructure as with dojo and jQuery (or write it yourself). I’d go into more detail but I can’t work on this further at the moment. One hint: I think jQuery’s pipe method would do wonders here.

The other options that come to mind is to rewrite it to use a stack which would save the ans variable and maybe something signifying what part of the current function invocation you would need to go back to.