(define (shuffle ls)
  (let ((len (length ls)))
    (or (and (< len 2) ls)
        (let ((item (list-ref ls (random len))))
          (cons item (shuffle (remove (cut equal? <> item) ls)))))))

(define yodize (o string-join shuffle (cut string-split <> " ")))

(define (shuffle ls)
  (let ((len (length ls)))
    (if (< len 2)
        ls
        (let loop ((x (random len))
                   (a '())
                   (b ls))
          (if (zero? x)
              (append (shuffle (reverse b))
                      (shuffle a))
              (loop (- x 1)
                    (cons (car b) a)
                    (cdr b)))))))

(define shuffle
  (lambda (l random)
    (let ((len (length l)))
      (map cdr
           (sort! (map (lambda (x) (cons (random len) x)) l)
                  (lambda (x y) (< (car x) (car y)))) ) ) ) )

(define (shuffle ls)
  (sort ls (lambda _ (zero? (random 2)))))

(use srfi-1)

(define (shuffle l)
  (if (null? l)
    '()
    (receive
      (h t) (split-at l (random (length l)))
      (cons (car t) (shuffle (append h (cdr t)))))))

(define (shuffle l)
  (let ((v (list->vector l)))
    (let loop ((i (vector-length v))
               (r '()))
      (if (zero? i)
        r
        (let* ((x (random i))
               (in (- i 1))
               (rn (cons (vector-ref v x) r)))
          (vector-set! v x (vector-ref v in))
          (loop in rn))))))

;;; Permute (shuffle): Return a random permutation of input vector. From Knuth
;;; "Algorithm P" (3rd ed, vol. 2, p. 145).
;;;   vec: vector to permute
;;; Note that rint will have to be replaced with a different RNG proc.
(define (permute vec)
  (do ((x (f64vector-quick-copy vec))
       (j (fx- (f64vector-length vec) 1) (fx- j 1)))
      ((= j 0) x)
    (f64vector-swap! x j (rint 0 j))))