Ramda Documentation

2023-08-04 12:42:11

A sensible practical library for JavaScript programmers.

Why Ramda?

There are already a number of wonderful libraries with a practical taste. Sometimes, they’re meant to be general-purpose toolkits, appropriate for working in a number of paradigms. Ramda has a extra centered purpose. We needed a library designed particularly for a practical programming fashion, one which makes it simple to create practical pipelines, one which by no means mutates person knowledge.

What’s Completely different?

The first distinguishing options of Ramda are:

Ramda emphasizes a purer practical fashion. Immutability and side-effect free capabilities
are on the coronary heart of its design philosophy. This can assist you get the job completed with easy,
elegant code.
Ramda capabilities are mechanically curried. This lets you simply construct up new capabilities
from outdated ones just by not supplying the ultimate parameters.
The parameters to Ramda capabilities are organized to make it handy for currying. The info
to be operated on is usually provided final.

The final two factors collectively make it very simple to construct capabilities as sequences of less complicated capabilities, every of which transforms the information and passes it alongside to the following. Ramda is designed to help this fashion of coding.

Introductions

Philosophy

Utilizing Ramda ought to really feel very similar to simply utilizing JavaScript.
It’s sensible, practical JavaScript. We’re not introducing
lambda expressions in strings, we’re not borrowing consed
lists, we’re not porting over all the Clojure capabilities.

Our fundamental knowledge buildings are plain JavaScript objects, and our
normal collections are JavaScript arrays. We additionally maintain different
native options of JavaScript, akin to capabilities as objects
with properties.

Purposeful programming is in good half about immutable objects and
side-effect free capabilities. Whereas Ramda doesn’t implement this, it
permits such fashion to be as frictionless as attainable.

We purpose for an implementation each clear and chic, however the API is king.
We sacrifice quite a lot of implementation class for even a barely
cleaner API.

Final however not least, Ramda strives for efficiency. A dependable and fast
implementation wins over any notions of practical purity.

Set up

To make use of with node:

$ npm set up ramda

Then within the console:

const R = require('ramda');

To make use of immediately in Deno:

import * as R from "https://deno.land/x/ramda@v0.27.2/mod.ts";

or utilizing Nest.land:

import * as R from "https://x.nest.land/ramda@0.27.2/mod.ts";

To make use of immediately within the browser:

<script src="path/to/yourCopyOf/ramda.js"></script>

or the minified model:

<script src="path/to/yourCopyOf/ramda.min.js"></script>

or from a CDN, both cdnjs:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

or one of many under hyperlinks from jsDelivr:

<script src="//cdn.jsdelivr.internet/npm/ramda@0.25.0/dist/ramda.min.js"></script>
<script src="//cdn.jsdelivr.internet/npm/ramda@0.25/dist/ramda.min.js"></script>
<script src="//cdn.jsdelivr.internet/npm/ramda@newest/dist/ramda.min.js"></script>

(word that utilizing newest is taking a major threat that ramda API modifications might break your code.)

These script tags add the variable R on the browser’s international scope.

Or you may inject ramda into nearly any unsuspecting web site utilizing the bookmarklet.

Word for variations > 0.25
Ramda variations > 0.25 do not have a default export.
So as a substitute of import R from 'ramda';, one has to make use of import * as R from 'ramda';
Or higher but, import solely the required capabilities by way of import { functionName } from 'ramda';

Word for ES6 module and browsers
With the intention to entry to the ES6 module in browsers, one has to offer the content material of the es listing (see under for the construct directions) and use import * as R from './node_modules/ramda/es/index.js';

Construct

npm run construct creates es, src directories and updates each dist/ramda.js and dist/ramda.min.js

Partial Builds

It’s attainable to construct Ramda with a subset of the performance to cut back its file dimension. Ramda’s construct system helps this with command line flags. For instance in the event you’re utilizing R.compose, R.cut back, and R.filter you may create a partial construct with:

npm run --silent partial-build compose cut back filter > dist/ramda.customized.js

This requires having Node/io.js put in and ramda’s dependencies put in (simply use npm set up earlier than working partial construct).

Set up particular capabilities

Install individual functions with bit, npm and yarn with out putting in the entire library.

Documentation

Please overview the API documentation.

Additionally out there is our Cookbook of capabilities constructed from Ramda that you could be discover helpful.

The Title

Okay, so we like sheep. That is all. It is a quick title, not already
taken. It might as simply have been eweda, however then we might be
compelled to say eweda lamb!, and nobody desires that. For non-English
audio system, lambs are child sheep, ewes are feminine sheep, and rams are male
sheep. So maybe ramda is a grown-up lambda… however in all probability not.

Operating The Check Suite

Console:

To run the check suite from the console, you have to have mocha put in:

npm set up -g mocha

Then from the basis of the challenge, you may simply name

mocha

Alternately, in the event you’ve put in the dependencies, by way of:

npm set up

then you may run the checks (and get detailed output) by working:

npm check

Browser:

You should use testem to
check throughout completely different browsers (and even headlessly), with livereloading of
checks. Set up testem (npm set up -g testem) and run testem. Open the
hyperlink offered in your browser and you will note the leads to your terminal.

You probably have PhantomJS put in, you may run testem -l phantomjs to run the
checks fully headlessly.

Utilization

For v0.25 and up, import the entire library or choose ES modules immediately from the library:

import * as R from 'ramda'

const {id} = R
R.map(id, [1, 2, 3])

Destructuring imports from ramda doesn’t essentially forestall importing the whole library. You’ll be able to manually cherry-pick strategies like the next, which might solely seize the components crucial for id to work:

import id from 'ramda/src/id'

id()

Manually cherry choosing strategies is cumbersome, nevertheless. Most bundlers like Webpack and Rollup supply tree-shaking as a approach to drop unused Ramda code and cut back bundle dimension, however their efficiency varies, mentioned here. Here’s a abstract of the optimum setup based mostly on what know-how you might be utilizing:

Webpack + Babel – use babel-plugin-ramda to mechanically cherry choose strategies. Dialogue here, instance here
Webpack solely – use UglifyJS plugin for treeshaking together with the ModuleConcatenationPlugin. Dialogue here, with an instance setup here
Rollup – does a nice job correctly treeshaking, no particular work wanted; instance here