What are the best Functional languages to learn for web-frontend development?

Question

11

Options
Considered

196

User
Recs.

Aug 26, 2018

Last
Updated

Here’s the Deal

The Best 1 of 10 OptionsWhy?

Best Functional languages to learn for web-frontend development	Price	Site	Current stable version
91 Elm	-	http://elm-lang.org/	0.18
82 ClojureScript	Open Source	https://clojurescript.org/	1.9
-- Reason ML	-	–	–
-- Scala	-	scala-lang.org	2.12.6
-- Purescript	-	–	–

See Full List

9 Other Options Considered

ClojureScript

Top Pro

Live interactive programming with figwheel

Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding! Every time you save your ClojureScript source file, the changes are sent to the browser so that you can see the effects of modifying your code in real time. See More

Top Con

Syntax may seem cryptic to people not used to Lisp

Lisp is sometimes called "syntax-less" and this is bewildering to those steeped in Algol-type syntax (Java, Javascript, C, etc). Being a dialect of Lisp, ClojureScript's syntax may seem cryptic and hard to understand for people not used to it. While Lisp has very little syntax compared to other languages and it's generally considered pretty terse, there's still an initial overhead in learning the language. See More

Webdev Tory Anderson's Experience

Lisp has a little learning curve because it is so different -- but the syntax is so minimal and elegant that writing becomes sheer joy. Add to the fact that there is superb tooling around Clojurescript (especially Figwheel) and you have a true winner. For me, the most rewarding part of working with all flavors of Clojure is the way they evolve your programming skills (Lisp enlightenment). See More

Specs

Site:https://clojurescript.org/

Current stable version:1.9

Price:Open Source

GZipped size:32 kB

Top Pro

Share application logic between browser and Clojure server

Clojure is also able to run web servers, so one can reap similar benefits to NodeJS in terms of sharing code between client and server. See More

Top Pro

Simple syntax

Lispness makes ClojureScript trivial to comprehend after an initial learning overhead. See More

Top Pro

Targets Google Closure-ready JavaScript for immense optimizations

Google's Closure Library converts regular JavaScript into a highly optimized form - including dead code analysis/elimination. It can even remove pieces of unused code from 3rd party libraries (eg, if you import jQuery but only use one function, Google Closure includes only that piece). See More

Top Pro

Easy to use existing JavaScript libraries

Clojure and ClojureScript are designed to be able to interact with their host. So the language by design makes it is easy to use existing JS libraries. See More

Top Pro

Can be used with React out of the box

Top Pro

The Spec core library

From the creator of Clojure: Spec is a new core library (Clojure 1.9 and Clojurescript) to support data and function specifications in Clojure. Writing a spec should enable automatic: Validation, Error reporting, Destructuring, Instrumentation, Test-data generation and Generative test generation. See More

Top Pro

Excellent build tools

Both Leiningen and Boot are great build tools that manage code dependencies and deployment. See More

Top Pro

Excellent tools for web development

ClojureScript has superb wrappers around React.js (see Reagent) that make building single-page apps a breeze. With figwheel, it's a web dev experience unlike any other -- hotloaded code, repl interaction, and instantly reflected changes make good development fun and fast. You can add things like Garden to make CSS-writing part of the same holistic experience and suddenly all development is a pleasant, smooth process. See More

See All

Scala

Top Pro

Immutable values

The immutable values make it perfect for working with concurrency. See More

Top 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. See More

Specs

Site:scala-lang.org

Current stable version:2.12.6

Price:Open Source (Free)

Top Pro

Type inference

Scala offers type inference, which, while giving the same safety as Java's type system, allows programmers to focus on the code itself, rather than on updating type annotations. See More

Top Con

JavaScript runtime seems immature

By the time of writing this, Scala doesn't seem quite usable on front-end since Scala.js didn't yet reach a release version. See More

Top Pro

Multiparadigm

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. See More

Top Pro

Compiles to JavaScript

Since we are talking about web frontends and because of the popularity of single page applications, Scala also compiles to JavaScript (search for Scala-JS). See More

Top Pro

Compiles to JVM bytecode

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. See More

See All

Purescript

Top Con

Lots of dependencies needed to get started

Purescript is written in Haskell, but meant to be used with Node.js. As a result, to get started , users must install ghc, cabal, node.js, grunt, and bower. Purescript also has its own compiler, and different semantics form Haskell, and so even after installing, there's still some overhead to getting productive with Purescript. See More

Top Pro

High performance FFI code

The Eff monad, which is used for FFI code, optimizes out calls to bind, and supports tail call optimization, resulting in clean, efficient Javascript. The psc compiler also specifically recognizes the ST monad, and transforms scoped variables into mutable Javascript variables, for even more efficient code. See More

Top Con

Slow compilation

On large project, for example Halogen See More

Top Pro

Pure functional language

You cannot have side effects, unless a function is explicitly defined as so. See More

Top Pro

Type safety

Compiling should be your first unit test. A tight type system (static and hopefully strong) will catch many logic errors that are often difficult to spot through debugging. In languages like PureScript, if it compiles, it often runs properly. See More

Top Pro

Has row polymorphism and extensible effects

Top Pro

Higher kinded types

Has Typeclasses and RankNTypes See More

Top Pro

Modules can be compiled to CommonJS

Modules compiled to CommonJS can be included with 'require', making it incredibly simple to call Purescript code from Javascript. See More

See All

F#

Top 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. See More

Top Con

.NET's garbage collection is slow

Specs

Site:http://www.fsharp.org

Current stable version:4.1

License:Apache 2.0

IDE Support:Visual Studio, Code, Rider

Top Pro

Fable Javascript transpiler creates good readable javascript

Top Pro

Allows to use the same language for web-frontend and server backend

Top Pro

Concise syntax

F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write. See More

Top Pro

Runs on the CLR

Since F# runs on the Common Language Runtime or CLR, it has access to the entire .NET Framework, as well as libraries written in other .NET languages such as C#, VB.NET, and C++/CLI. See More

Top Pro

Natively supported by Visual Studio

This is a .Net language natively supported by Visual Studio. Though it is not as tooled up as C# the support is still substantial. In particular, C# deployment scenarios can be enabled for it with small C# wrapper projects. See More

Top Pro

Built-in REPL

Makes it easy to write scripts and explore the language. See More

See All

JavaScript

Top Pro

Native support in browser

Top Con

No syntactic or standard library support for value semantics

Especially unfortunate for those writing in a functional/value-oriented style is that JavaScript objects are compared by reference when using === and when performing lookups in arrays, maps, and sets. See More

Specs

Engine:V8/ChakraCore

Author:Ryan Dahl/Joyent

Version(LTS):8.x

ECMAScript Modules:Available (as a flag) (only on Node 8.x-10.x)

See All Specs

Top Pro

Powerful syntactic support for value oriented programming

While writing in a mutable style is easy in JavaScript, writing in an immutable style has now become effortless with the advent of features such as Object Rest/Spread. These make it as easy, if not easier, to create new values as it is to modify existing one. Users of TypeScript or Flow that adopt this style further gain the advantage that they can omit almost all type annotations and still benefit from full analysis. See More

Top Pro

First-class functions with lexical closures

While certainly not the only language with these features, this pro alone is so powerful that it compensates for most of JavaScript's problems. You'll learn to use closures and higher-order functions well in JavaScript, because you have to. And then you can generalize this knowledge to any other language that has these, and the good ones do. See More

Top Pro

Required for web development

If you are looking to create web projects, you will have to learn Javascript in order to develop the client side code. If you learn the foundations of programming in JavaScript you can reapply that education later in building web applications. See More

See All

OCaml

Top Pro

Supports multi-paradigm development

Ocaml is a very strong functional programming language but also supports some object oriented programmig technics See More

Top Con

Not very strong support for concurret / parallel development for the backend

This is in the moment meaningless for web frontend development. However it has relevance for the server backend development where concurrency is an advantage. Backends can definately be developed in Ocaml but lack of good concurrency support is a Con compared to other canguages. And as it is often adventurous to use the same language for frontend and backend, the impact needs to be considered. See More

Specs

Site:http://ocaml.org

Current stable version:4.0.6

Price:Open source (Free)

License:LGPL version 2.1

See All Specs

Top Pro

Encourages functional style

It steers you towards a functional style, but doesn't bother you with purity and "monads everywhere" like other languages, such as Haskell. See More

Top Con

Some small strange quirks in the syntax

It uses +. instead of + for floating point additions (and -. *. /. etc), which is easy to get used to, but it's not quite clear what it's supposed to be good for. See More

Top Pro

Uses one of the best transpilers

It comes with Bucklescript, which currently is one of the best Javascript transpilers. See More

Top Pro

Established technology

Top Pro

Strong editor integration

The merlin editor tool provides all you need to develop OCaml in your favourite editor. See More

Top 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. See More

Top 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 repositories, even if the dependencies do not exists on OPAM. See More

Top Pro

Easier transition from other programming languages

Ocaml supports functional but also object-oriented and procedural programming. See More

See All

Haskell

Top Con

Steep 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. See More

Top Pro

Terse

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. See More

Specs

Site:https://www.haskell.org/

Top 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. See More

Top 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. See More

Top 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. See More

Top 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. See More

Top 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. See More

Top 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. See More

Top Con

Delayed 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. See More

Top 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. See More

Top 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. See More

Top 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. See More

Top 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. See More

See All

Haste

Top Pro

Generates small, reasonably performant code

Haste generates a small amount of JavaScript which usually performs well. See More

Top Con

Lacks some minor Haskell functionality

Lacks support for Template Haskell for example. See More

Top Pro

Based on GHC frontend

So all syntax and type system extensions are supported. See More

Top Pro

Client and Server as the same application

Haste was designed to allow both the client and server to be written as parts of the same, type-safe application. This is in stark contrast to most other options, where the client and server are considered two separate entities, resulting in extra manual validation code and more chances for type errors. See More

Top Pro

Almost full power of Haskell

Haste supports the Haskell 2010 standard except for Template Haskell as well as most GHC extensions. See More

See All

Lua

See flagged products

Request recommendations from the community

I Recommend...

Help millions of people make better decisions.

Each month, over 2.8 million people use Slant to find the best products and share their knowledge. Pick the tags you’re passionate about to get a personalized feed and begin contributing your knowledge.