When comparing Haskell vs Racket, the Slant community recommends Racket for most people. In the question“What is the best programming language to learn first?” Racket is ranked 2nd while Haskell is ranked 27th. The most important reason people chose Racket is:
Racket is based on Scheme (LISP Family) and is very similar to Clojure. So there are a ton of (). The reason it is easier to learn is that it is not trying to be "Pure" if there is even such a thing in terms of Functional Programming. The great thing about Racket is it has everything included. You get DrRacket for developing programs. You want to add a picture to your software you can insert pictures. If you want to add libraries just open the package manager. The Syntax is an opinion but it really does feel easier to see what is happening since everything is in brackets) Racket is a really a Programming Language for making Programming Languages. So there are smaller syntax Racket called Student Racket which makes things easier to pick up.
Ranked in these QuestionsQuestion Ranking
Pro Forces you to learn pure functional programming
It is pure and does not mix other programming paradigms into the language. This forces you to learn functional programming in its most pure form. You avoid falling back on old habits and learn an entirely new way to program.
Pro Open source
All Haskell implementations are completely free and open source.
Pro Mathematical consistency
As Haskell lends itself exceedingly well to abstraction, and borrows heavily from the culture of pure mathematics, it means that a lot more code conforms to very high-level abstractions. You can expect code from vastly different libraries to follow the same rules, and to be incredibly self-consistent. It's not uncommon to find that a parser library works the same way as a string library, which works the same way as a window manager library. This often means that getting familiar and productive with new libraries is often much easier than in other languages.
Pro Highly transferable concepts
Haskell's referential transparency, consistency, mathematics-oriented culture, and heavy amount of abstraction encourage problem solving at a very high level. The fact that this is all built upon little other than function application means that not only is the thought process, but even concrete solutions are very transferable to any other language. In fact, in Haskell, it's quite common for a solution to simply be written as an interpreter that can then generate code in some other language. Many other languages employ language-specific features, or work around a lack of features with heavy-handed design patterns that discourage abstraction, meaning that a lot of what is learned, and a lot of code that is needed to solve a particular problem just isn't very applicable to any other language's ecosystem.
Pro Referentially transparent
Haskell's Purely Functional approach means that code is referentially transparent. This means that to read a function, one only needs to know its arguments. Code works the same way that expressions work in Algebra class. There's no need to read the whole source code to determine if there's some subtle reference to some mutable state, and no worries about someone writing a "getter" that also mutates the object it's called on. Functions are all directly testable in the REPL, and there's no need to remember to call methods in a certain order to properly initialize an object. No breakage of encapsulation, and no leaky abstractions.
Pro Very few language constructs
The base language relies primarily on function application, with a very small amount of special-case syntax. Once you know the rules for function application, you know most of the language.
Pro Hand-writeable concise syntax
Conciseness of Haskell lets us to write the expression on the whiteboard or paper and discuss with others easily. This is a strong benefit to learn FP over other languages.
Pro Functions curry automatically
Every function that expects more than one arguments is basically a function that returns a partially applied function. This is well-suited to function composition, elegance, and concision.
Pro Easy syntax for people with a STEM degree
Since the basic syntax is very similar to mathematics, Haskell syntax should be easy for people who have taken higher math courses since they would be used to the symbols used in maths.
Pro Easy to read
Haskell is a very terse language, particularly due to its type inference. This means there's nothing to distract from the intent of the code, making it very readable. This is in sharp contrast to languages like Java, where skimming code requires learning which details can be ignored. Haskell's terseness also lends itself to very clear inline examples in textbooks, and makes it a pleasure to read through code even on a cellphone screen.
Pro Quick feedback
It's often said that, in Haskell, if it compiles, it works. This short feedback loop can speed up learning process, by making it clear exactly when and where mistakes are made.
Pro Popular in teaching
Haskell is really popular in universities and academia as a tool to teach programming. A lot of books for people who don't know programming are written around Haskell. This means that there are a lot of resources for beginners in programming with which to learn Haskell and functional programming concepts.
Pro Powerful Categorical Abstractions
Makes categorical higher order abstractions easy to use and natural to the language
Pro Racket was designed to teach functional programming from the start
Racket is based on Scheme (LISP Family) and is very similar to Clojure. So there are a ton of (). The reason it is easier to learn is that it is not trying to be "Pure" if there is even such a thing in terms of Functional Programming. The great thing about Racket is it has everything included. You get DrRacket for developing programs. You want to add a picture to your software you can insert pictures. If you want to add libraries just open the package manager. The Syntax is an opinion but it really does feel easier to see what is happening since everything is in brackets)
Racket is a really a Programming Language for making Programming Languages. So there are smaller syntax Racket called Student Racket which makes things easier to pick up.
Pro Realm of Racket is an excellent entry-level guidebook
Realm of Racket teaches the big-bang approach for managing world state. It does so by walking the reader through the development of small games. There are few guidebooks that are as useful and entertaining.
Pro Free resources to Learn
Includes several free online books and great documentation.
Pro Easily embeddable
Racket is famously embedded in the game engine underlying Naughty Dog's Uncharted and The Last of Us games, because it proved to be so easy to embed.
Pro Syntax fits to functional programming
Although syntax is different from that of mainstream languages, S-expressions are a perfect match to functional programming.
Pro Active community
Racket has an active community of users/developers that makes it easy to get help when needed.
Pro Great RPEL IDEA included Dr. Racket
Con Difficult learning curve
Haskell lends itself well to powerful abstractions - the result is that even basic, commonly used libraries, while easy to use, are implemened using a vocabularly that requires a lot of backround in abstract mathematics to understand. Even a concept as simple as "combine A and B" is often, both in code and in tutorials, described in terms of confusing and discouraging terms like "monad", "magma", "monoid", "groupoid", and "ring". This also occasionally bears its ugly head in the form of complicated error messages from type inference.
Con Language Extensions lead to unfamiliar code
Haskell's language extensions, while making the language incredibly flexible for experienced users, makes a lot of code incredibly unfamiliar for beginners. Some pragmas, like NoMonomorphismRestriction, have effects that seem completely transparent in code, leading beginners to wonder why it's there. Others, like ViewPatterns, and particularly TemplateHaskell, create completely new syntax rules that render code incomprehensible to beginners expecting vanilla function application.
Con Symbols everywhere
Haskell allows users to define their own infix operators, even with their own precedence. The result is that some code is filled with foreign looking operators that are assumed to be special-case syntax. Even for programmers who know they're just functions, operators that change infix precedence can potentially break expectations of how an expression is evaluated, if not used with care.
Con Package manager is unstable & lacking features
Cabal (There are other choices but this is the most popular) can not uninstall a package. Also working at a few locations it is difficult to have the same environment for each one be the same.
Con You need some time to start seeing results
Haskell's static typing, while helpful when building a project, can be positively frustrating for beginners. Quick feedback for errors means delaying the dopamine hit of code actually running. While in some languages, a beginner's first experience may be their code printing "Hello World" and then crashing, in Haskell, similar code would more likely be met with an incomprehensible type error.
Con Lazily Evaluated
Haskell's lazy evaluation implies a level of indirection - you're not passing a value, you're passing a thunk. This is often difficult to grasp not just for beginners, but for experienced programmers coming from strictly evaluated languages. This also means that, since for many, strict evaluation is their first instinct, initial expectations of a function's performance and complexity are often broken.
Con You have to learn more than just FP
Haskell is not only a functional language but also a lazy, and statically typed one. Not only that but it's almost necessary to learn about monads before you can do anything useful.
Con Documentation for most packages is short and lacking
A few Haskell packages are well documented but this is the exception, not the rule.
Most of the time a list of function signatures is what passes for documentation.