[racket-dev] racket vs. scheme vs. clojure (as it appears to others)

8 minutes ago, Danny Yoo wrote:
> >>  "Scheme" is usually a liability when someone used it in school
> >>  years ago (other than with HtDP).
> 
> Small anecdote: I had gone a small presentation at WPI about
> teaching alternative concurrent programming models to
> undergraduates.  The presenter wanted to explore teaching with
> channels and actors.  They chose Google Go as the language to
> explore those models.  I raised the question in the after-session:
> why not use Racket?  The presenter responded with some shock: he had
> no idea Racket supported threads or had channels.

This is completely off-topic wrt the original thread, but IMO having
these tools in Racket means that you can play with them and contrast
various approaches in a better way.  One example I show in my class is
the sieve way of generating prime numbers -- I do that first in lazy
racket:

  (define nats (cons 1 (map add1 nats)))
  (define (divides? n m)
    (zero? (modulo m n)))
  (define (sift n l)
    (filter (lambda (x) (not (divides? n x))) l))
  (define (sieve l)
    (cons (first l) (sieve (sift (first l) (rest l)))))
  (define primes (sieve (rest nats)))

and then I show them a solution that is based on channels which is
more or less a direct translation from Rob Pike's talk at google
(which is why it relies heavily on state in each thread), and then one
more that uses generators.

  ----------------------------------------------------------------------
  #lang racket

  (define-syntax-rule (bg expr ...) (thread (lambda () expr ...)))

  (define nats
    (let ([out (make-channel)])
      (define (loop i) (channel-put out i) (loop (add1 i)))
      (bg (loop 1))
      out))
  (define (divides? n m)
    (zero? (modulo m n)))
  (define (filter pred c)
    (define out (make-channel))
    (define (loop)
      (let ([x (channel-get c)])
        (when (pred x) (channel-put out x))
        (loop)))
    (bg (loop))
    out)
  (define (sift n c)
    (filter (lambda (x) (not (divides? n x))) c))
  (define (sieve c)
    (define out (make-channel))
    (define (loop c)
      (define first (channel-get c))
      (channel-put out first)
      (loop (sift first c)))
    (bg (loop c))
    out)
  (define primes
    (begin (channel-get nats) (sieve nats)))

  (define (take n c)
    (if (zero? n) '() (cons (channel-get c) (take (sub1 n) c))))

  (take 10 primes)
  ----------------------------------------------------------------------

  ----------------------------------------------------------------------
  #lang racket

  (require racket/generator)

  (define nats
    (generator ()
      (letrec ([loop (lambda (i)
                       (yield i)
                       (loop (add1 i)))])
        (loop 1))))
  (define (divides? n m)
    (zero? (modulo m n)))
  (define (filter pred g)
    (generator ()
      (letrec ([loop (lambda ()
                       (let ([x (g)])
                         (when (pred x) (yield x))
                         (loop)))])
        (loop))))
  (define (sift n g)
    (filter (lambda (x) (not (divides? n x))) g))
  (define (sieve g)
    (define (loop g)
      (define first (g))
      (yield first)
      (loop (sift first g)))
    (generator () (loop g)))
  (define primes
    (begin (nats) (sieve nats)))

  (define (take n g)
    (if (zero? n) '() (cons (g) (take (sub1 n) g))))

  (take 10 primes)
  ----------------------------------------------------------------------


-- 
          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!