Slant community chat on Discourse| 19 Recommended Products | Recommendations | Site | Current stable version | Price |
|---|---|---|---|---|
| #1 Haskell· · · | 64 | 6 | https://www.haskell.org/ | 8.0.2 | Open source (free) |
| #2 Elm· · · | 31 | 4 | http://elm-lang.org/ | 0.18 | Open Source |
| #3 Clojure· · · | 38 | 9 | www.clojure.org | 1.8.0 | – |
| #4 Elixir· · · | 19 | 3 | https://elixir-lang.org | 1.4.5 | Open source (Free) |
| #5 F#· · · | 29 | 7 | – | – | – |
| #6 Racket· · · | 11 | 2 | – | – | – |
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. This avoids you 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 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 concre...
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 ofte...
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 preceden...
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&#...
Pro The Elm architecture offers a simple pattern for all programs
What could be nicer when creating a program than being able to follow a simple, reusable recipe: model (represent your domain), action (progress your story), view (show it).
Pro Growing community
Elm is gaining popularity, somewhat faster than many of the other solutions here. This translates to more code examples, more documentation, and more libraries.
Con Missing syntactic sugar ('where' clauses, pattern guards)
Elm is missing a lot of syntactic sugar that Haskellers may consider core, such as 'do' notation, 'where' clauses, pattern guards, and operator sections.
Pro Immutability is the default
Clojure programmers are highly encouraged to use immutable data in their code. Therefore, most data will be immutable by default. State change is handled by functions (for transformations) and atoms (an abstraction that encapsulates the idea of some entity having an identity).
Pro Minimal syntax
Being a LISP, programs are simple: they're just functions and data. That it doesn't get bogged down with syntax or the loftier FP concepts like monads makes it one of most approachable functional languages for beginners.
Con Confusing error messages
Clojure's error messages more often than not are very confusing. They usually involve stack traces that do not thoroughly explain where the error was caused or what caused it.
Con Dynamic types
You can put anything in. This makes reasoning about code after a time has passed very hard.
Pro Great documentation
Elixir's documentation is very good. It covers everything and always helps solving any problem you may have. It's also always available from the terminal.
Pro Great for concurrency
Leverages the existing Erlang BEAM VM
Con Some design choices may seem strange
Some design choices could have been a little more appealing, for example: using "do...end" comes natural in Ruby for blocks but Elixir uses them for everything and it looks pretty weird: Enum.map [1, 2, 3], fn(x) -> x * 2 end or receive do {:hello, msg} -> msg {:world,
Pro Easier transition from other paradigms
Since F# is not a purely functional language, it lends itself to being more easily picked up by programmers that have experience with other paradigms.
Pro Concise syntax
F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write.
Con I wish it had ad-hoc polymorphism (á la Type Classes)
You have generics, you have interfaces, you have inheritance, you have a lot of things at your disposal but you don't have Type Clases. They can be emulated using some clever constructs but there's nothing like having the real thing.
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 inc...
Pro Free Resources to Learn
Includes several free online books and great documentation.
Know any negative aspects of this option?
Pro Excellent type system
Intersection and union types make expressing some concepts very easy and intuitive
Pro Regular syntax
Makes it very easy to parse and read code
Pro Simple syntax
Scheme syntax is extremely regular and easy to pick up. A formal specification of the syntax fits onto just a few pages; it can be introduced informally in a paragraph or two. Students are not distracted by remembering how to write if statements or loops or even operator precedence because every...
Pro Great, well known textbooks available
There is a set of very strong textbooks introducing CS and programming using Scheme. These books are available for free online. The most famous example--and one of the most famous CS books full stop--is Structure and Interpretation of Computer Programs usually known as SICP. This book introduces...
Con Not purely functional
Scheme is a multi-paradigm language including metaprogramming and procedural elements alongside functional elements. As such it will not give a clear impression of a purely functional language.
Pro Supports both Functional and OOP paradigms
Scala supports both Functional and Object Oriented styles of programming. Beginners can learn both paradigms without having to learn a new language, and experts can switch between the two according to what best suits their needs at the time.
Pro Compiles to JVM bytecode, making applications written in Scala cross-platform
Aside from Java itself, Scala is by far the most popular of the many JVM languages. If you're developing for Android, or a similar JVM-only platform, or otherwise need out-of-the-box cross-platform compatibility, but the performance of a compiled language, Scala is the way to go.
Con Can be intimidating for beginners
Scala is an industrial language. It brings functional programming to the JVM, but not with a "start small and grow the language" perspective, but rather a very powerful language for professional programmers.
Con Limited type inference
Compared to other languages with type inference, such as Haskell, Scala's implementation is quite limited
Pro Great tooling support
Since Kotlin is made by Jetbrains (the developers of IntelliJ IDEA) so it stands to reason that the IntelliJ support for Kotlin is also great. Besides that, Kotlin also works well with existing Java tools such as Eclipse, Maven, Gradle, Android Studio, etc...
Pro Easy adoption for existing Java programmers
Kotlin runs on the JVM and Java interoperability has been one of the main objectives since the language was born. It runs everywhere Java does; web servers, mobile devices (Android), and desktop applications. It also works with all the major tools in the Java ecosystem like Eclipse, IntelliJ, Mave...
Con May be hard for programmers already used to imperative style to learn functional programming from Kotlin
Since Kotlin does not enforce any particular paradigms and is not purely functional, it can be pretty easy to fall back to imperative programming habits if a programmer comes from an imperative background.
Con The need for Java interoperability has forced some limitations
The need to make Kotlin interoperable with Java has caused some unintuitive limitations to the language design.
Pro Actively developped functional programming language at the forefront of research
Functional programming is based on the lambda calculus. OCaml is in its functional parts almost pure lambda calculus, in a very practical manner: useful for many daily programming tasks. The acitve development makes improvements to the type system like generalized algebraic data types (GADT) or po...
Pro Sophisticated and easy-to-use package manager
OPAM is a package manager for OCaml, which is really easy to use, just like npm. It creates a .opam folder in home directory. The documentation is great as well, and you can switch between multiple versions of OCaml for each project. You can also package your project and publish it on OPAM repos...
Con Strong focus on *nix systems, lacking native support for MS Windows
Lacks native support for Windows systems.
Pro 25 year old language, with core unchanged in last 10 years
Still actively developed, but most recent changes have been in libraries and IDE and platform support. Language is considered "perfected"... though not quite.
Pro Compiled language speed from interpreted language.
Each built in operator is a C/asm function, and special code further optimizes some operator combinations. Result is optimized C speed from quick parsing. Array orientation parses and compiles a function once, and applies it to all array items.
Con Syntax is pure madness
quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)
Pro Great for writing distributed applications
Erlang is made to be parallel and distributed. Because it's very easy to write code that uses multiple processor cores, it's also very easy to write applications that span multiple servers.
Pro Battle proven
Erlang has been used in production for more than 20 years now. During that time it has proven itself over and over again that works great in both small startups and large-scale enterprise systems. Erlang has been used extensively by Ericsson themselves. For example, the AXD301 ATM, which is one of
Con Strange syntax
Erlang's syntax may feel very strange to 99% of programmers who have never used it. This is because it does not share any similarities or common syntax definitions that are found in all the other languages that are used today.
Con Useful in only one niche
Erlang is not really a general purpose language. It has a very special and well-defined niche where it towers above everything else. It's specialized in scalability and in distributed applications. Which is not necessarily a bad thing per se, but it still lacks and falls behind other languages...
Pro Full dependent types
Idris not only has support for type classes, but is a fully dependently typed language, giving you the full power to statically verify your code.
Pro Domain driven design and type driven development
Because of full dependent types in Idris, the programmer can focus more on modelling the domain with types and waste less time fixing common bugs that the type checker will catch. Dependent types help apply type driven development and a lot of code auto generation, making the compiler and type ch...
Con Weaker type inference
As type inference is undecidable for dependently-typed languages, Idris cannot offer the full type inference that Haskell supports, and so more type annotations will be needed.
Con Different semantics from Haskell
Idris, while similar to Haskell, has strict semantics, which may cause some confusion if your backend is done in Haskell. If using Idris, it would make sense to do the backend in Idris as well, if not for the fact that Idris currently has fewer libraries available for web development than Haskell.
Pro Powerful module system
The module system that Standard ML uses gives the programmer the power to define custom data types whose internal implementation is invisible to other programmers using the module.
Pro Implementing laziness is trivial
Since mutability is only confined to a special type of reference cells, implementing laziness in SML can be done in only 20 lines of code.
Con Not very popular outside academia
SML is mostly used in academia and doesn't have many uses in industry. While it's a good language for learning functional programming concepts, the language itself won't be very useful.
Con Not designed for functional programming
Bare minimal list functions and no tail recursions. Biggest hangup is the imperative syntax which makes it difficult to make it have weak expressions.
Con Slightly slower
When microseconds are involved and very high data throughput, python can respond slower than a base C/C++ application. But not very much.
Pro Concepts, techniques, and models of computer programming
CTM teaches all the major paradigms with mathematical rigor, including functional programming.
Know any negative aspects of this option?
Pro Java - a functional programming language
Java is hostile to functional programming. If you write Java code that has no side-effects, that doesn't read or change the local object's state. That's not how Java is written. Your side-effect free code will be peppered with static keywords, and they'll frown and drive you out of...
Con Not really functional
Doesn't help in learning FP in any way.
Comments
Welcome to the Slant Community
Stop spending hours researching
Slant is written by a community helping you be informed. Let us know what you’re passionate about to get an awesome personalized feed.