Closing Channels in Scheme

(define (main)
  (define jobs (make-channel 5))
  (define done (make-channel))

  ;; Here's the worker thread. It repeatedly receives
  ;; from jobs with (receive jobs). In Scheme, we don't have
  ;; a direct equivalent to Go's special 2-value form of receive,
  ;; so we'll use a separate function to check if the channel is closed.
  (thread
   (lambda ()
     (let loop ()
       (let ((job (receive jobs)))
         (if (channel-closed? jobs)
             (begin
               (display "received all jobs\n")
               (channel-put done #t))
             (begin
               (display (string-append "received job " (number->string job) "\n"))
               (loop)))))))

  ;; This sends 3 jobs to the worker over the jobs channel, then closes it.
  (do ((j 1 (+ j 1)))
      ((> j 3))
    (channel-put jobs j)
    (display (string-append "sent job " (number->string j) "\n")))
  (close-channel jobs)
  (display "sent all jobs\n")

  ;; We await the worker using channel synchronization.
  (receive done)

  ;; Reading from a closed channel succeeds immediately,
  ;; returning a special value that indicates the channel is closed.
  ;; We'll use our channel-closed? function to check this.
  (let ((more-jobs? (not (channel-closed? jobs))))
    (display (string-append "received more jobs: " (if more-jobs? "true" "false") "\n"))))

;; Helper functions to simulate Go's channel behavior
(define (make-channel . capacity)
  (let ((ch (make-queue)))
    (if (null? capacity)
        ch
        (set-queue-capacity! ch (car capacity)))
    ch))

(define (channel-put ch value)
  (enqueue! ch value))

(define (receive ch)
  (dequeue! ch))

(define (close-channel ch)
  (set-queue-closed! ch #t))

(define (channel-closed? ch)
  (queue-closed? ch))

;; Run the main function
(main)

This Scheme code simulates the behavior of the original Go program for closing channels. Here’s an explanation of the key parts:

We define a main function that sets up the channels and worker thread.
Instead of Go’s goroutines, we use Scheme’s thread function to create a separate thread for the worker.
We simulate Go’s channel operations using a queue-based implementation. The make-channel, channel-put, receive, close-channel, and channel-closed? functions provide similar functionality to Go’s channel operations.
The worker thread uses a loop to continuously receive jobs from the channel. It checks if the channel is closed using our channel-closed? function.
We send jobs to the worker and close the channel in the main thread, similar to the Go code.
We use channel synchronization to wait for the worker to finish, just like in the Go example.
Finally, we check if more jobs are available by testing if the channel is closed.

This Scheme implementation provides a close approximation of the Go program’s behavior, demonstrating channel communication and closing in a Scheme context.

Non Blocking Channel Operations in Scheme

Range Over Channels in Scheme

Learn X By Example

Title here

Closing Channels in Scheme