Loop in PLT Scheme

Question

How can I implement loop in plt-scheme like in java-

for(int i=0;i<10;){
     for(int j=0;j<3;){
          System.out.println(""+j);
          j++;
     }
      System.out.println(""+i);
      i++;
}

Answer 1

Your example in Java doesn't directly map onto the Scheme language by just learning a few new keywords as there aren't explicit constructs for implementing a for loop in Scheme (unless you write a construct yourself!). The cookbook way to do this in Scheme is to define a recursive function that loops over a list. Here's an example of how to do a for-loop style function in Scheme:

(define (doit x x-max dx)
  (if (<= x x-max)
    (begin
      ;;...perform loop body with x...
      (doit (+ x dx) x-max dx))))

(doit a b dx) ; execute loop from a to b in steps of dx

Taken from this page:

Guile and Scheme Links

Here's another link to a page that describes the ideas you need to understand to translate loops from imperative languages to Scheme:

Scheme Looping Constructs

Scheme is a really interesting language to learn, you should also read the Structure and Interpretation of Computer Programs, which is the textbook formerly used for teaching Scheme at MIT.

Answer 2

In PLT you can do this:

(for ([i (in-range 10)])
  (for ([j (in-range 3)]) (printf "~s\n" j))
  (printf "~s\n" i))

Answer 3

The iteration construct in Scheme is "do", you can look it up in the R5RS specification.

The example you gave would look something like this:

(do ((i 0 (+ i 1))) ((> i 9))
  (do ((j 0 (+ j 1))) ((> j 2))
    (display j)
    (newline))
  (display i)
  (newline))

(do ...) is a bit more general than what shows up in this example. You can for example make it return a value instead of just using it for its side effects. It is also possible to have many "counters":

(do ((i 0 (+ i 1) 
     (j 0 (+ j 2)) 
    ((stop? i j) <return-value>)
   exprs...)

Answer 4

I'm suggesting you to take a look to Michele Simionato's "The adventures of a pythonista in schemeland". It's for python->scheme, but, it's really well written and, more importantly, it's from procedural->functional.