All of this sounds like you're one of these people who see parens and run away screaming "LISP!". Yes, the default Racket syntax uses S-expressions, but concluding that it's in some way lumped with Emacs Lisp is extremely wrong. And yes, Racket has syntax that can be tweaked using macros -- but it's a far stretch to go from this to that being the thing that drives all Racket coding. After all, OCaml now has CamlP4 as something that is an integral part of the language -- does that mean that meta-programming is now the thing that drives OCaml coding???
Another point: yes, Racket programmers know and use tail-calls, but that has nothing to do with "the looping constructs provided in the library" since those are implemented in terms of the same facility. The existence of these loops is therefore not making the language any less functional than the fact that you can implement a while loop in Haskell. The bottom line is that Racket is as functional a language as the interpretation of the term was before Haskell kidnapped it and turned it into some religious point.
(BTW, if you want to bash lisps, do yourself a favor and drop the all-caps "LISP" -- it immediately demonstrates the kind of limited knowledge you have on it.)
I strongly disagree. The vast majority of Racket code I've looked at would be far easier to translate into, say, Common Lisp than Haskell (or Erlang, which is probably a more illustrative example since it has dynamic typing). Emacs Lisp is pretty different because it doesn't have lexical scoping and it's only really used in the Emacs runtime environment (although it resembles Common Lisp syntactically), but programs written in Racket, Common Lisp, and Clojure (and other LISP dialects that support lexical scoping and macros) tend to be way more similar to each other than are programs written in Racket and languages we traditionally think of as functional. If you're still not convinced, I'm sure a bit of digging online would reveal way more crossover between Racket and other LISP dialects by the same developers than you get with Haskell or ML developers crossing over to Racket.
As for your parenthetical add-on, I'm not bashing LISPs at all. I think Racket is a beautiful language, in part precisely because it has the power of a LISP dialect. As for your second point, using the capitalized form is the only unambiguous word that refers to the family because many developers in the Common Lisp community use Lisp to mean CL. The reddit style "do yourself a favor" and ill-formed judgments about people's "limited knowledge" are way less constructive than asking "why did you use that spelling." Please keep discussions on HN objective and civil.
Um, when I write code in Typed Racket (and I have a whole course using it), the code tends to be much more similar to ML than to conventional Lisps. When I write code in Lazy Racket, it is somewhat like a dynamically typed version of Haskell, and unsurprisingly not too similar to other Lisps. Same goes for a whole bunch of stuff. Another random example: there's a whole library of functional data structures that is based on Okasaki's book.
In fact, if you want to focus on macros as some kind of a driving force for code -- then it that exact aspect (a) macros in Racket can be very different than macros in other Lisps; (b) more than that, there are many kinds of macros in Racket that you cannot write in those Lisps. As for digging on-line for crossover code from other Lisps that finds its way into Racket: you'll obviously find a lot of Scheme code, but practically nothing from other Lisps. The bottom line is that the syntactic "lots of parens" similarity is an extremely shallow one.
Bottom line: Racket is roughly at the same level of a "functional programming language" as ML etc, certainly more than Python and Ruby where side-effects are embraced much quicker. Like you said, "even have equivalents of map..." -- whereas in Racket these kind of functional/non-destructive operations are expected. (For example, the Racket GC is tuned to perform well when allocating lots of short-term objects, something that is a direct result of FP being the most dominant style.)
And yes, I know that you're not bashing Lisp -- you're just quick to lump all Lisps on the same pile, and reach the obviously bogus conclusion that first-class syntax is the thing that drives code. (That's a point that is subjectively obvious to me, as someone who has been in this part of the PL world for more than two decades.) "LISP" is, BTW, just an outdated spelling, period. It's true that in CL circles "Lisp" is taken as implicitly meaning "Common Lisp", but in the same circles "LISP" is taken implicitly as "an outdated spelling for Lisp, therefore Common Lisp" unless you're one of the old farts whose making a reference to LISP 1.5 or something as ancient.
Another point: yes, Racket programmers know and use tail-calls, but that has nothing to do with "the looping constructs provided in the library" since those are implemented in terms of the same facility. The existence of these loops is therefore not making the language any less functional than the fact that you can implement a while loop in Haskell. The bottom line is that Racket is as functional a language as the interpretation of the term was before Haskell kidnapped it and turned it into some religious point.
(BTW, if you want to bash lisps, do yourself a favor and drop the all-caps "LISP" -- it immediately demonstrates the kind of limited knowledge you have on it.)