Slant community chat on Discourse| 21 Recommended Products | Recommendations | Site | Current stable version | GZipped size |
|---|---|---|---|---|
| #1 Haskell· · · | 71 | 6 | – | – | – |
| #2 Clojure· · · | 48 | 10 | www.clojure.org | 1.8.0 | 5.7Mb, requires JAVA |
| #3 Elm· · · | 36 | 6 | http://elm-lang.org/ | 0.18 | 23.2 kB |
| #4 Elixir· · · | 21 | 3 | https://elixir-lang.org | 1.5.1 | 3.61 MB (without required Erlang VM) |
| #5 F#· · · | 44 | 7 | http://www.fsharp.org | 4.1 | – |
| #6 Racket· · · | 10 | 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 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...
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 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 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 Easier to make front ends than JS
This is perhaps subjective but I think it holds pretty true.
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 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 Concise syntax
F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write.
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.
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 Free Resources to Learn
Includes several free online books and great documentation.
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 incl...
Know any negative aspects of this option?
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 s...
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 f...
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 Limited type inference
Compared to other languages with type inference, such as Haskell, Scala's implementation is quite limited
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.
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 che...
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 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 pol...
Pro One of the best for writing compilers
OCaml is compiled to native binary, so it's amazingly fast. Being a member of ML-family languages, it has expressive syntax for trees, and has great LLVM support.
Con Strong focus on *nix systems, lacking native support for MS Windows
Lacks native support for Windows systems.
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 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.
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.
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 *Not* a fully functional language
Python is missing several features that make it fully functional, and has several design issues that make pure-functional programming a chore at best. The biggest of these is the limitations of lambdas and dysfunctional closure scoping.
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...
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.
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 Strict typing
Checks your code at compile time.
Pro Multi-paradigm
Imperative, OOP, functional programming in one language.
Con Still in pre 1.0
The same code can be used for web, server, desktop and mobile.
Pro No operator precedence rules
(... within each of the 3 operator classes) makes reading code easier. Very simple parsing rules.
Pro Language reference has simple one page index
Complete core programming functional tools allow writting programs and libraries without imports.
Con Syntax is pure madness
quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)
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.