(Racket) permute

#lang racket
(require racket/generator)
(define (permute v)
  (generator ()
             (define count 0)
             (define len (vector-length v))
             (define sorted (sort (vector->list v) <))
             (let loop ([level 0])
               (if (> level (sub1 len))
                   (begin
                     (set! count (add1 count))
                     (yield v))
                   (for ([i sorted])
                     (unless (for/or ([priorLevel (in-range 0 level)])
                               (= i (vector-ref v priorLevel)))
                       (vector-set! v level i)
                       (loop (add1 level))))))))

(define (permutations v)
  (define r '())
  (define p (permute v))
  (let loop ()
    (let ([x (p)])
      (unless (void? x)
        (set! r (cons (vector->list x) r))
        (loop))))
  r)

(displayln (permutations (vector 1 2 3)))

---

((3 2 1) (3 1 2) (2 3 1) (2 1 3) (1 3 2) (1 2 3))