atomic VS ramda

I wanted ClojureScript, without transpilation, in the browser so badly I implemented much of it in plain JS. But JS still lacks first-class protocols (although there is a T39 proposal for them) so I have to implement protocols first. And I can tell you from having implemented much of Clojure myself in plain JS that it's protocols all the way down. 80% of my library are types and their protocols.

I've watched a lot of talks, but it was Rich Hickey's which most captivated me and, ultimately, inspired big change in how I coded. After discovering Clojure I was so desiring FP (i.e. ClojureScript) in the browser without a build step and hoard of dependencies that I wrote my own library.

I fell in love with Clojure and ported most of the tools to plain ol' JavaScript. I stole reactives and FRP from Elm. I write a functional core then wrap it with an imperative shell. It's been my mainstay for 10 years now.

What I did was looked past the languages at the ideas and saw they could be applied everywhere, including JavaScript. Take a look at my example programs (via prior link) and you can see Clojure applied to the JavaScript/browser realm.

I have found that the amount of code needed to support any page/app need not be massive. I have implemented modern board games with 250-300KB of js and the core lib I use on all my projects maxes out around 250KB, unminified. The lib itself is built on the premise of build avoidance.

I do JavaScript most of the time, but I was so inspired that I ported the Clojure mindset into the web development world so I could use it even in the absence of Clojure. I know there's ClojureScript, but I wanted the goodness without transpilation.

So I don't even do Clojure per se. I do Clojure in JavaScript without ClojureScript.

I use functional core, imperative shell. It would have you write a core which is a pure simulation. Write everything in the core using immutable data and pure functions. I elaborate on that here, along with examples.

JavaScript is great for point-free programming! Make sure you check out Ramda.js https://ramdajs.com/

It’s fun in the sense that solving a puzzle is fun, but I avoid it for anything I need to maintain long-term.

But it’s good practice for understanding combinators which is useful for some kinds of problems.

This is very cool. I remember I got sucked into things like Ramda going down this functional programming rabbit hole :-)

https://ramdajs.com/

To create our pipeline, I'm going to use the pipe function from the NodeJS ramda library instead of building my own.

Other libraries to check out are pratica and ramda

I recently took ownership of the new types/ramda repo. This repo is re-exported by @types/ramda and is the first step to bringing type definitions for ramda in-house. We're already hard at work correcting major issues, adding full currying support, and general bug fixes

I'm going to be honest. You probably don't need to use currying in JavaScript. In fact, trying to fit it in your code is going to do more harm than good, unless it's just for fun. Currying only becomes useful when you fully embrace functional programming, which, in JavaScript, means using a library like Ramda instead of the standard built-in functions.

Lodash gets so many things wrong I’d rather not see it in most projects. I appreciate a good utility library for JS projects but my go-to choice has to be Ramda[1]. Every function it exports is curried and works great with pipe which enables me to write highly reusable and composable functions in pointfree notation. I have never been as productive with lodash, and I find the functional style easier to read

[1] https://ramdajs.com/

Do note though that ramda is different from rambda. 👍 (Granted they are very similar!)