What I imagine “foo” is referring to is that your function isn’t thread-safe, because the binding for seqrnd is shared amongst all threads. (seqrnd is also not re-entrant: if you end up in the debugger, for example, and call seqrnd from there, you will destroy the current execution’s state.)

To fix these problems, use one of the correct solutions that you are “allergic” to.

It would be really nice to do this with memoizing.
But having it working except for literals is already a nice thing.

(define (shuffle xs)
  (if (or (null? xs) (null? (cdr xs))) xs
      (let split ((xs xs) (odd '()) (even '()))
        (if (pair? xs)
            (split (cdr xs) (cons (car xs) even) odd)
            (let merge ((odd (shuffle odd)) (even (shuffle even)))
              (cond ((null? odd) even)
                    ((null? even) odd)
                    ((zero? (random 2)) (cons (car odd) (merge (cdr odd) even)))
                    (else (cons (car even) (merge odd (cdr even))))))))))

A faster functional shuffle comes from Al Petrofsky; it first partitions the list randomly, then merges the two pieces back together randomly:

(define (shuffle xs)
  (let shuffle ((xs xs) (acc '()))
    (if (null? xs) acc
        (if (null? (cdr xs)) (cons (car xs) acc)
            (let split ((xs xs) (x1 '()) (x2 '()))
              (if (null? xs)
                  (if (null? x1)
                      (split x2 '() '())
                      (shuffle x1 (shuffle x2 acc)))
                  (if (zero? (random 2))
                      (split (cdr xs) (cons (car xs) x1) x2)
                      (split (cdr xs) x1 (cons (car xs) x2)))))))))

If you speak Haskell, Oleg Kiselyov presented a perfect shuffle of complexity O(n log n) in comp.lang.functional in September 2001. I won’t quote it here, because the implementation only makes sense if you read the accompanying derivation.

(defun benchmark (fn)
 (dotimes (x 1000)
   (let ((seq (loop for i from 1 to 1000 collect (random i))))
     (funcall fn seq))))
 
(time (benchmark #'random-shuffle))
(time (benchmark #'seqrnd))

CLISP 2.41 (interpreted):

Real time: 25.72314 sec.
Run time: 10.665971 sec.
Space: 86264000 Bytes
GC: 164, GC time: 0.669959 sec.

Real time: 72.53122 sec.
Run time: 29.028109 sec.
Space: 79356432 Bytes
GC: 152, GC time: 0.5233 sec.

Bottom line: RANDOM-SHUFFLE 3x faster, SEQRND slightly less space.

CLISP 2.41 (compiled)

Real time: 19.819485 sec.
Run time: 8.232797 sec.
Space: 86016072 Bytes
GC: 164, GC time: 0.663291 sec.

Real time: 28.287846 sec.
Run time: 10.196001 sec.
Space: 79108984 Bytes
GC: 151, GC time: 0.519969 sec.

Bottom line: RANDOM-SHUFFLE 1.35x faster, SEQRND slightly less space.

SBCL 1.0.15:

Evaluation took:
  13.861 seconds of real time
  5.013006 seconds of user run time
  0.126658 seconds of system run time
  [Run times include 0.074 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  52,039,552 bytes consed.

Evaluation took:
  4.639 seconds of real time
  2.263186 seconds of user run time
  0.026665 seconds of system run time
  [Run times include 0.009 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  30,302,776 bytes consed.

Bottom line: SEQRND 3x faster, SEQRND 3/5 space.

Test cases:

(seqrnd (list 1 1 1 2 3))

(let ((x “foo”))
(seqrnd (list x x x 3 x)))

I didn’t benchmark the consing (yet), but I’m positive the hash table will be faster; I’ll check this later.