SearchYC.com

  (def whatever (row) (row "something"))     ; unsafe
  (def whatever (row) (do.row "something"))  ; safe
  (def whatever (row) (or.row "something"))  ; safe
  ; The "or.row" one is possibly more efficient, since it expands to
  ; "row", but I use "do.row" 'cause I don't want to desensitize myself
  ; to "or".
  
  (def whatever (tab key) (= tab.key "something"))     ; unsafe
  (def whatever (tab key) (= do.tab.key "something"))  ; doesn't work
  (def whatever (tab key) (= or.tab.key "something"))  ; confuses me
  (def whatever (tab key) (= .key.tab "something"))    ; safe

  arc> (coerce "." 'sym)
  |.|
  arc> '|.|
  |.|
  arc> (is '|.| (coerce "." 'sym))
  t

As for . specifically, it's special to the reader because of dotted lists:

  arc> (nthcdr 3 '(a b c . terminator))
  terminator

  arc> '(a b c . <- . x y z)
  (<- a b c x y z)

Next, there are some things you can simplify. In shuffle_members, you have "let temp 0 @", which isn't doing much, and you also have "@ arr" at the end, which is unnecessary. Unlike 'let, 'w/table automatically returns the value its variable has at the end of the body. In span_let, there's a place where you check [and (is (type _) 'cons) (is (car _) 'scope)], but FYI, that's exactly what [iscar _ 'scope] does. :) Also, I don't expect you to know this right away, but you can accomplish the decreasing loop using (down i (- max min) 1 ...); 'down is a backwards 'for.

Finally, it's really not a big deal, but these names would be more consistent with Arc:

  binding-function-list*
  span-let
  shuffle-numbers

I don't really think it makes it more readable, but that's only because it introduces new rules I'm not accustomed to. The "let temp 0" line is clearly supposed to wrap the whole area, but I had to open up Arc and check to see whether the 'for loop wrapped the 'loop loop or not. (Your indentation might have been a clue, but I suspected a bug.)

  (do1 nil (= foo (string:n-of 100000 "@_")))
  
  (defop foo req
    (let x copy.foo
      (prn ellipsize.x)))
  
  
  ; I'm defining 'bar just to be sure it's the strings themselves which
  ; consume the memory.
  
  (do1 nil (= bar (string:n-of 10 "@_")))
  
  (defop bar req
    (let x copy.bar
      (prn ellipsize.x)))
  
  
  ; And here's an op that should really cause a problem.
  
  (do1 nil (= baz (string:n-of 100000 "@_")))
  
  wipe.bazzes
  
  (defop baz req
    (let x copy.baz
      (push x bazzes)
      (prn ellipsize.x)))
  
  
  (thread:asv)

Here's a take on it. It isn't so painful, probably because it only takes about O(N^2) time. :)

  (def commonalities-at (a b bstart (o threshold 1))
    (accum acc
      (withs (stop (min len.a (- len.b bstart))
              run 0
              bank [do (unless (< run threshold)
                         (acc:list run (- _ run)))
                       (= run 0)])
        (when (< stop 0) (err "The start index was out of range."))
        (for i 0 (- stop 1)
          (if (is a.i (b:+ bstart i))
            ++.run
            bank.i))
        bank.stop)))
  
  (def commonalities (a b (o threshold 1))
    (accum acc
      (forlen bstart b
        (each (run offset) (commonalities-at a b bstart threshold)
          (acc:list run offset (+ bstart offset))))))
  
  (def show-top-commonalities (a b number-to-show (o threshold 1))
    (each (run astart bstart) (firstn number-to-show
                                (sort (fn (a b) (> a.0 b.0))
                                      (commonalities a b threshold)))
      (pr "matched " run " chars at " astart " and " bstart ": ")
      (write:cut a astart (+ astart run))
      (pr "=")
      (write:cut b bstart (+ bstart run))
      (prn)))

  arc> (show-top-commonalities w1 w1 10 10)
  matched 1038 chars at 0 and 0: [snip]
  matched 27 chars at 561 and 852: "CGGTAGATATCACTATAAGGCCCAGGA"="CGGTAGATATCACTATAAGGCCCAGGA"
  matched 24 chars at 621 and 927: "GTTTTTTTGCTGCGACGTCTATAC"="GTTTTTTTGCTGCGACGTCTATAC"
  matched 22 chars at 393 and 411: "TCATGACAAAACAGCCGGTCAT"="TCATGACAAAACAGCCGGTCAT"
  matched 18 chars at 447 and 504: "TGACTGTGAAACTAAAGC"="TGACTGTGAAACTAAAGC"
  matched 18 chars at 429 and 528: "TCATAATAGATTAGCCGG"="TCATAATAGATTAGCCGG"
  matched 18 chars at 546 and 1002: "AGTCGTATTCATAGCCGG"="AGTCGTATTCATAGCCGG"
  matched 16 chars at 677 and 971: "GCGGCACTAGAGCCGG"="GCGGCACTAGAGCCGG"
  matched 15 chars at 620 and 665: "AGTTTTTTTGCTGCG"="AGTTTTTTTGCTGCG"
  matched 15 chars at 318 and 465: "TACTAATGCCGTCAA"="TACTAATGCCGTCAA"
  nil
  arc> (do1 nil (time:commonalities w1 w1 10))
  time: 2494 msec.
  nil
  arc> (do1 nil (time:commonalities w1 w1))
  time: 4657 msec.
  nil

  arc> (show-top-commonalities w1 w2 10 10)
  matched 11 chars at 339 and 390: "GCTGTGATACT"="GCTGTGATACT"
  matched 10 chars at 799 and 843: "TAGCAATAAG"="TAGCAATAAG"
  matched 10 chars at 318 and 456: "TACTAATGCC"="TACTAATGCC"
  matched 10 chars at 338 and 575: "TGCTGTGATA"="TGCTGTGATA"
  matched 10 chars at 69 and 768: "TGATAAATAA"="TGATAAATAA"
  nil
  arc> (do1 nil (time:commonalities w1 w2 10))
  time: 1622 msec.
  nil
  arc> (do1 nil (time:commonalities w1 w2))
  time: 3264 msec.
  nil

The first thing I think of when I hear the name "Racket" is tennis, suggesting the language is but one frequently visited taking-off point in some larger system. That would be okay if it were more obvious how it was meant; for instance, maybe the Racket language is a taking-off point on the way to the other languages PLT Racket supports. One could also talk about parentheses as being like Pong paddles, but that's a stretch.

The second thing I think of is a loud, grating noise, suggesting the language is a pain to read. This may or may not be an accurate description of the Racket language--hello parentheses--but the fact that it's an aversive connotation suggests that the language eschews utility (like Brainf___). Then again, I suppose naming a language after an intentionally obnoxious noise is better than naming it after an unintentional speech impediment (Lisp).

The third thing I think of is organized crime. Now, that's in the same ballpark as "evil mastermind," which was the first thing I thought of when I heard of Scheme (the second thing being blueprints), and indeed that's the association they're shooting for. In the context of that association, there's even a vaguely useful meaning to it; in my mind, small groups and individual masterminds scheme, whereas large organizations and conglomerates racket.

The thing is, if any language deserves to be named after organized crime, I'd say it's either something like C# whose use rather exclusively benefits one closed platform (not that it would name itself that way), or something like Mono which provides one of the few alternatives to such a platform. Trying to equate "organized illegal activity" with education and with multiple-language techniques doesn't make nearly as much sense.

Oh, and finally, "Racket" is eerily close to "Rocket," which is actually sorta positive for me (as my moniker shows). It almost makes me wanna write a parody dialect or something. ^_^