For in Scheme

Scheme provides various ways to create loops. Here are some basic types of loops in Scheme.

(define (main)
  ; The most basic type, with a single condition.
  (let loop ((i 1))
    (when (<= i 3)
      (display i)
      (newline)
      (loop (+ i 1))))

  ; A classic initial/condition/after loop.
  (do ((j 0 (+ j 1)))
      ((>= j 3))
    (display j)
    (newline))

  ; Another way of accomplishing the basic "do this N times" iteration
  ; is to use a named let loop with a counter.
  (let loop ((i 0))
    (when (< i 3)
      (display "range ")
      (display i)
      (newline)
      (loop (+ i 1))))

  ; A loop without a condition will run repeatedly
  ; until you break out of the loop or return from
  ; the enclosing function.
  (call/cc
   (lambda (break)
     (let loop ()
       (display "loop")
       (newline)
       (break #f)
       (loop))))

  ; You can also continue to the next iteration of the loop.
  (do ((n 0 (+ n 1)))
      ((>= n 6))
    (when (even? n)
      (continue))
    (display n)
    (newline)))

(main)

When you run this program, you’ll see:

1
2
3
0
1
2
range 0
range 1
range 2
loop
1
3
5

In Scheme, we use different constructs to achieve looping behavior:

We use let with recursion for basic conditional loops.
The do special form provides a classic looping construct.
Named let loops can be used for counted iterations.
Infinite loops can be created with recursive functions, and we use call/cc (call-with-current-continuation) to simulate a break.
The continue concept is simulated by using when to skip iterations in a do loop.

These constructs provide similar functionality to the for loops in other languages, allowing you to create various types of iterations in Scheme.

Constants in Scheme

If Else in Scheme

Learn X By Example

Title here

For in Scheme