That just becomes a debate about the definition of a functional language. The point is that unlike Haskell, SML, and OCaml (the last two aren't "pure" in the sense of syntactically enforcing referential transparency like Haskell, but they strongly encourage a functional design), Racket is first and foremost a LISP. You can use it to write and make use of a lot of functional abstractions, and it certainly is better suited to that style of programming than C or Java is, but Python and Ruby are just about equally suited for that style of programming, and they even have equivalents of map, filter, fold, lambda, etc.
Racket code doesn't look like Haskell, the MLs, or even dynamically typed "functional" languages (like Erlang). It looks like LISP. What drives your coding is not functional abstractions or object-oriented data structures (which it can do equally well) or anything like that. What drives your coding is the fact that syntax itself is a first-class data structure. You have access to the reader. You can write macros that adapt the language to anything you want. You can write a DSL in a few hundred lines that might save you tens of thousands of lines.
Now, Racket is certainly good for functional programming. In fact, some Racket developers prefer the Scheme-style tail recursion method of iteration (via the named let or letrec) to the looping constructs provided in the library, even when for loops would be just as effective. In the same way, not all Common Lisp programmers like the loop macro, and some (e.g. pg) actually use Common Lisp in a style that resembles functional programming. However, don't think of Racket as a functional language. That's as misleading as calling C++ a procedural one, even though you could write all your code C-style without ever using objects. Racket is a LISP, which means it can be adapted to fit virtually any paradigm. Racket is far closer to Common Lisp and Clojure than it is to literally any non-LISP.
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.
Aside from the fact that I still don't think that "a Lisp" is a thing, Racket is not bound to s-expr syntax. The racklog/prolog #langs make that very clear.
I'm talking about the racket #lang, not the collection of all languages that the distribution can interpret. R5RS, for example, is included in the distribution, but the R5RS found in the Racket distribution is identical to that of any other Scheme interpreter or compiler, so discussion about its features has nothing to do with discussions specific to Racket. There are also experimental variations of the main racket language like typed racket and lazy racket, but I don't have enough familiarity with them to discuss their classification. I'd assume lazy racket is mainly used in a functional style. But anyway, the main Racket language is very much an s-expression based language (the typed and lazy varieties are as well). What do you mean by not believing in LISP as a classification of languages? Are you saying you don't think s-expression based languages are at least as similar to each other as, say, OOP languages or logic languages are too each other?
What do you mean by not believing in LISP as a classification of languages? Are you saying you don't think s-expression based languages are at least as similar to each other as, say, OOP languages or logic languages are too each other?
I'm saying exactly that. Qi/Shen are basically Haskell with parentheses but because of those parens we call them Lisps. My Scheme->x86 compiler uses an s-expr assembly language as its final IR. That language has about as much in common with Lisp as C does.
It also has a dataflow language, a typed language, a lazy language, etc. Racket is not one language, it's a language family platform (or language laboratory).
