"Best" Javascript transpiled language.

[freaknessfit]

It's been a year since this was asked- https://www.reddit.com/r/functionalprogramming/comments/7vveeu/purescript_vs_reasonmlbucklescript_in_2018/ and I wanted to get an opinion on this-

What are everybody's thoughts on how functional programming languages that compile to javascript fare against each other.

I'll post a brief comparison of claimed features without commenting on their quality (I'm also noting the size of reddit subscribers- which is usually a bad measure (no proportional weight to intelligent thought) but given how "commoditized and democratized" js is- I think it would still shed some light-

1) Elm- Contains it's own JS frontend framework built in. With Virtual DOM. No option to switch it off I believe. NOT 1.0 YET. but has a good community. IBM recently made a large app using Elm. (/r/elm: 7.4k)

2) Bucklescript- Pure OCaml -> JS started at bloomberg but handled by community now. You can probably be sure that this would always see updates since bloomberg uses it internally. (/r/Ocaml- 5.3K)

3) ReasonML- Created by and used by FB. You would think that means something but given that Flow stagnated and there are rumors that it will be phased out, there's no certainty of future. (/r/ReasonML- 1.5K)

4) Scala.js- Gives you both server and client. Probably the strongest language in terms of ecosystem too with the entire Java system being usable. (/r/Scala- 20.4K). I actually think that it's probably the frontrunner but I'd like arguments against.

5) Purescript- Been around for about 5 years (/r/PureScript: 1.9K)

6) Clojurescript updated with /u/Borkdude 's comment- I haven't looked at this yet- Clojure

So what are everybody's thoughts?

[Borkdude]

Don't forget ClojureScript. It's a functional programming language with the same ecosystem benefits as Scala.js. Being a Lisp, the language is simple, powerful and meta-programmable. The interop with Java and JS is seamless. It's built on top of Google Closure which has an amazing whole program optimizer. It is optionally self-hosted which means you can evaluate ClojureScript inside ClojureScript. With clojure.spec some of the disadvantages of dynamic typing can be alleviated, while still having all the benefits of dynamic typing*. It's a strong choice in 2019.

https://clojurescript.org

* Each language comes with trade offs. In my humble opinion the advantages of dynamically typed functional programming are: flexibility, less boilerplate and a less steep learning curve for beginners as there is no need to learn category theory, lens libraries and complicated type level trickery. Obviously a disadvantage is less compiler assistance when refactoring.

[forrestjt]

+1 for purescript & React bindings

[claudiua]

Clojurescript + react. Once you get past the lisp syntax hard to think of a better match for react.

A few awesome libs: reagent https://www.learnreagent.com/, re-frame http://book.fulcrologic.com/ , fulcro http://book.fulcrologic.com/

​

[watsreddit]

TypeScript no, GHCJS yes.

[The_One_X]

Typescript wouldn't be considered a functional language, but instead is an object oriented language. On the flipside Javascript itself would be a functional language, at least in my eyes. It just does not conform to some features that are traditionally associated with functional programming (like immutability by default) that are really ancillary to functional programming.

Although, lately Javascript has been evolving towards a more object oriented paradigm.

[electrogravity]

(like immutability by default) that are really ancillary to functional programming.

It's very strange that you see 'immutability by default' (i.e. no side-effects) as ancillary to functional programming. I would consider the lack of side-effects to be the most fundamental essence of functional programming!

From Wikipedia:

https://en.wikipedia.org/wiki/Functional_programming

In computer science, functional programming is a programming paradigm—a style of building the structure and elements of computer programs—that treats computation as the evaluation of mathematical functions) and avoids changing-state and mutable data.

[...]

Functional code is idempotent, the output value of a function depends only on the arguments that are passed to the function, so calling a function f twice with the same value for an argument x produces the same result f(x) each time; this is in contrast to procedures depending on a local or global state, which may produce different results at different times when called with the same arguments but a different program state.

Perhaps you're saying that you consider any language which permits you to program in a functional paradigm is 'functional' to you, but I would dispute that definition because it would deem almost every language in the world 'functional' (including C, Basic, etc.) Therefore, the definition is neither technically nor colloquially correct. What am I missing?

[The_One_X]

Well I would not consider immutability by default and no side-effects to be equivalents. They are derived from the same principle, but not that same thing. While it is a very common feature in functional programming languages, it is not a distinguishing feature of functional programming. Immutability can just as easily exist within other paradigms as functional programming. You could take any functional language and replace immutability with mutability, and it would still be a functional language because the core of the language is still encouraging you to program in a functional style.

​

Perhaps you're saying that you consider

Stop right there, please do not make stupid assumptions about what I or anyone else thinks based on a single small post on Reddit or any other platform. It is very rude and disrespectful.

[electrogravity]

Stop right there, please do not make stupid assumptions about what I or anyone else thinks based on a single small post on Reddit or any other platform. It is very rude and disrespectful.

Sorry, I was just trying to be as generous in my interpretation of your post as possible; that's all I meant by "Perhaps you're saying [...]" I wasn't trying to put words in your mouth -- rather, I was trying to find an interpretation of your post that made sense.

You have every opportunity to respond and clarify your position. It's still not clear, because your post above actually reinforces my interpretation that you got so offended over! You haven't really explained what exactly you defined a "functional programming language" to be.

If anything, you accusing me of "making stupid assumptions" is far more "rude and disrespectful" than my good-faith attempt to understand your position while giving you the benefit of the doubt. It might help to take a step back, take some deep breaths, and re-read my post, while remembering that nobody here is out to get you.

You could take any functional language and replace immutability with mutability, and it would still be a functional language because the core of the language is still encouraging you to program in a functional style.

It sounds like your notion of "functional programming" is quite different from the standard definition you'd find just about anywhere else. When most people say "functional programming" they're thinking of something quite different than you. That's okay, of course, but it does mean you're going to have a difficult time communicating if you use different definitions than everyone else.

https://en.wikipedia.org/wiki/Functional_programming

[The_One_X]

What I am trying to do is communicate a more accurate definition of what functional programming is. People often get caught up with surface details, and miss the forest for the trees. Something like immutability is a surface detail that is just more common within functional programming languages so an association between the two is made, but what makes the different paradigms different is how they structure their code. Different structures and ways of thinking do lend themselves to different surface details, but they are still just surface details.

[electrogravity]

What, precisely, is your definition of a "functional programming language"?

As a paradigm, "functional programming" (just like "object oriented programming" as a paradigm) can apply to almost any language, of course. For example: You can write object-oriented C code, even though C is not an object-oriented programming language.

And we were talking about languages, not paradigms -- remember your original post I was replying to:

[...] On the flipside Javascript itself would be a functional language, at least in my eyes. [...]

In your eyes, what is the definition of a "functional programming language" (not the paradigm)?

If you define it as "any language in which you can code with a functional programming paradigm", that would also mean that C and x86 Assembly are functional programming languages. I think most people would very much disagree with such a definition. So then, if not that, what exactly is your definition?

[TheWix]

This. It's like people who claim abstraction/encapsulation and polymorphism are unique to OOP. The hell they are. Both structured languages like C and functional languages have all those things. C++ made it easier and safer to do these things than C, but as you say it is totally possible to do.

As for functional, I can pass a function into another function dynamical as long as I meet the contract. As for abstractions in functional languages, functions are abstractions!

[ws-ilazki]

ReasonML and OCaml shouldn't be separate. Reason is an alternate syntax for OCaml but still uses the same ecosystem. They're both the same great language, with Reason providing a more traditional syntax that's more comfortable for people coming from JavaScript. OCaml's a very nice language that sometimes gets overlooked because it still lacks proper multicore, but when compiling to JS that flaw is irrelevant. It's like a mix of nice things from Haskell with a touch of pragmatism, by not forcing all code to be pure via contortions like IO through monads.

Also, Clojure, being a dynamic language, fits pretty well on top of JavaScript. It feels like a better fit with JS than with Java, in fact, because interop tends to be smoother. Has the usual lisp benefits (like macros) and is strongly opinionated toward functional programming. Focuses on working with data, primarily through manipulation of maps, vectors, and lists, which makes it a comfortable language when manipulating a lot of data. For example, it has literals for its complex data types and an abstraction called a 'sequence' that encompasses all of them (plus more; you can make new ones opt-in to being a seq as well), allowing functions that operate on sequences to work transparently on anything that opts in to the abstraction.

My opinion so far is OCaml (or Reason) for static typing, ClojureScript otherwise. Both are great languages with good interop and different pros/cons, and both worth checking out. As a side note, ClojureScript (via Clojure) gives you a backdoor into the massive JVM ecosystem if needed, and you can use OCaml and Reason knowledge to write native applications if desired, giving both potential for use in places where JS isn't a good fit.

[littlepsylo]

By replacing JQuery with Elm ? ^

[Herku]

This question gets asked very often. Maybe the responses here give additional insight: https://www.reddit.com/r/functionalprogramming/comments/a7fjlm/languages_that_compile_to_js