@crabas0npm/distinctio-dolorum-eos

v1.0.0

Published

7 months ago

Ramda =============

Downloads

0High
0Medium
0Low

colors concatMap bootstrap css uuid findLastIndex environment scheme request rm -fr eslint view pipe make dir workspace:*flatten tslib ECMAScript 2018 performant commander prune console symlink installer Array.prototype.includes yaml getPrototypeOf deterministic iteration waapi auth duplex URL task bound WeakSet _.extend jasmine bdd yup superagent mkdirp css-in-js hasOwn stylesheet mocha persistent babel flatMap react directory serialization deep pure Float64Array args reduce some ECMAScript 5 spinners BigInt64Array react-hook-form apollo side ECMAScript 2015 picomatch Iterator forms error ES2023 xss react-testing-library east-asian-width rm -rf slot mimetypes regular expressions Stream Int8Array inspect trimStart collection form-validation sequence typesafe write sigterm HyBi map parent read react pose entries take mkdir curl url generics operating-system guid api watching worker nope runtime irq [[Prototype]]debug bootstrap less limit color fixed-width merge exit patch a11y Int16Array preprocessor Microsoft dom string check Array.prototype.flatten hookform popmotion intrinsic compile less jsonschema phone proto concurrency random command ES2015 ReactiveX rgb language protocol-buffers traverse 3d spinner i18n tty windows CSSStyleDeclaration ES l10n setPrototypeOf busy error-handling lru framework optimist symbols typeof weakmap formatting queueMicrotask coercible ECMAScript 2019 asserts typedarrays circular drop css nesting term utils Object.entries form jwt listeners linewrap keys safe regexp private crypto packages multi-package validator call-bind ECMAScript 2023 validate json-schema estree chai authentication ES2021 dataview ascii folder setter consume metadata Float32Array equality libphonenumber logger ast bind typedarray key getintrinsic date WeakMap parse computed-types reducer package every json-schema-validator dataView symlinks emit korean css variable cli lazy push install handlers fast-deep-copy sort rangeerror colour flag delete inference chinese get querystring regular Promise module tools JSON-Schema -0 nested css babel-core classnames chromium WebSockets parents open function var transpiler descriptor RegExp.prototype.flags es2018 password number stringifier tdd middleware jsonpath shebang scheme-validation bundling call-bound const import internal classname deep-clone $.extend reuse visual performance node group 6to5 structuredClone flags mkdirs lint slice Symbol.toStringTag xterm from wrap assign whatwg shared .env Array.prototype.findLastIndex which accessor shim typed array Observables queue eslintplugin xhr negative zero ES3 prototype match argument idle minimal es6 gestures validation codes es-shims stable equal StyleSheet TypeScript data japanese watch callbound exec String.prototype.matchAll touch log iterate optimizer quote pnpm9 callback ReactiveExtensions variables in css byte enumerable cache serialize browser less mixins query three less figlet styled-components extra ES2016 plugin toSorted javascript package.json monorepo graphql arraybuffer writable ajax progress mime-db serializer mime toolkit moment lesscss zero tc39 CSS style findLast walk ECMAScript 2017 forEach immer look rate deepclone macos BigUint64Array valid jsdiff compare sham Map regex

Ramda

A practical functional library for JavaScript programmers.

Why Ramda?

There are already several excellent libraries with a functional flavor. Typically, they are meant to be general-purpose toolkits, suitable for working in multiple paradigms. Ramda has a more focused goal. We wanted a library designed specifically for a functional programming style, one that makes it easy to create functional pipelines, one that never mutates user data.

What's Different?

The primary distinguishing features of Ramda are:

Ramda emphasizes a purer functional style. Immutability and side-effect free functions are at the heart of its design philosophy. This can help you get the job done with simple, elegant code.
Ramda functions are automatically curried. This allows you to easily build up new functions from old ones simply by not supplying the final parameters.
The parameters to Ramda functions are arranged to make it convenient for currying. The data to be operated on is generally supplied last.

The last two points together make it very easy to build functions as sequences of simpler functions, each of which transforms the data and passes it along to the next. Ramda is designed to support this style of coding.

Introductions

Introducing Ramda by Buzz de Cafe
Why Ramda? by Scott Sauyet
Favoring Curry by Scott Sauyet
Why Curry Helps by Hugh Jackson
Hey Underscore, You're Doing It Wrong! by Brian Lonsdorf
Thinking in Ramda by Randy Coulman

Philosophy

Using Ramda should feel much like just using JavaScript. It is practical, functional JavaScript. We're not introducing lambda expressions in strings, we're not borrowing consed lists, we're not porting over all of the Clojure functions.

Our basic data structures are plain JavaScript objects, and our usual collections are JavaScript arrays. We also keep other native features of JavaScript, such as functions as objects with properties.

Functional programming is in good part about immutable objects and side-effect free functions. While Ramda does not enforce this, it enables such style to be as frictionless as possible.

We aim for an implementation both clean and elegant, but the API is king. We sacrifice a great deal of implementation elegance for even a slightly cleaner API.

Last but not least, Ramda strives for performance. A reliable and quick implementation wins over any notions of functional purity.

Installation

To use with node:

$ npm install @crabas0npm/distinctio-dolorum-eos

Then in the console:

const R = require('@crabas0npm/distinctio-dolorum-eos');

To use directly in Deno:

import * as R from "https://deno.land/x/@crabas0npm/[email protected]/mod.ts";

or using Nest.land:

import * as R from "https://x.nest.land/@crabas0npm/[email protected]/mod.ts";

To use directly in the browser:

<script src="path/to/yourCopyOf/@crabas0npm/distinctio-dolorum-eos.js"></script>

or the minified version:

<script src="path/to/yourCopyOf/@crabas0npm/distinctio-dolorum-eos.min.js"></script>

or from a CDN, either cdnjs:

<script src="//cdnjs.cloudflare.com/ajax/libs/@crabas0npm/distinctio-dolorum-eos/0.29.1/@crabas0npm/distinctio-dolorum-eos.min.js"></script>

or one of the below links from jsDelivr:

<script src="//cdn.jsdelivr.net/npm/@crabas0npm/[email protected]/dist/@crabas0npm/distinctio-dolorum-eos.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/@crabas0npm/distinctio-dolorum-eos@latest/dist/@crabas0npm/distinctio-dolorum-eos.min.js"></script>

(note that using latest is taking a significant risk that @crabas0npm/distinctio-dolorum-eos API changes could break your code.)

These script tags add the variable R on the browser's global scope.

Or you can inject @crabas0npm/distinctio-dolorum-eos into virtually any unsuspecting website using the bookmarklet.

Note for versions > 0.25 Ramda versions > 0.25 don't have a default export. So instead of import R from '@crabas0npm/distinctio-dolorum-eos';, one has to use import * as R from '@crabas0npm/distinctio-dolorum-eos'; Or better yet, import only the required functions via import { functionName } from '@crabas0npm/distinctio-dolorum-eos';

Note for ES6 module and browsers In order to access to the ES6 module in browsers, one has to provide the content of the es directory (see below for the build instructions) and use import * as R from './node_modules/@crabas0npm/distinctio-dolorum-eos/es/index.js';

Build

npm run build creates es, src directories and updates both dist/@crabas0npm/distinctio-dolorum-eos.js and dist/@crabas0npm/distinctio-dolorum-eos.min.js

Partial Builds

It is possible to build Ramda with a subset of the functionality to reduce its file size. Ramda's build system supports this with command line flags. For example if you're using R.compose, R.reduce, and R.filter you can create a partial build with:

npm run --silent partial-build compose reduce filter > dist/@crabas0npm/distinctio-dolorum-eos.custom.js

This requires having Node/io.js installed and @crabas0npm/distinctio-dolorum-eos's dependencies installed (just use npm install before running partial build).

Documentation

Please review the API documentation.

Also available is our Cookbook of functions built from Ramda that you may find useful.

The Name

Ok, so we like sheep. That's all. It's a short name, not already taken. It could as easily have been eweda, but then we would be forced to say eweda lamb!, and no one wants that. For non-English speakers, lambs are baby sheep, ewes are female sheep, and rams are male sheep. So perhaps @crabas0npm/distinctio-dolorum-eos is a grown-up lambda... but probably not.

Running The Test Suite

Console:

To run the test suite from the console, you need to have mocha installed:

npm install -g mocha

Then from the root of the project, you can just call

mocha

Alternately, if you've installed the dependencies, via:

npm install

then you can run the tests (and get detailed output) by running:

npm test

Browser:

You can use testem to test across different browsers (or even headlessly), with livereloading of tests. Install testem (npm install -g testem) and run testem. Open the link provided in your browser and you will see the results in your terminal.

If you have PhantomJS installed, you can run testem -l phantomjs to run the tests completely headlessly.

Usage

For v0.25 and up, import the whole library or pick ES modules directly from the library:

import * as R from '@crabas0npm/distinctio-dolorum-eos'

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

Destructuring imports from @crabas0npm/distinctio-dolorum-eos does not necessarily prevent importing the entire library. You can manually cherry-pick methods like the following, which would only grab the parts necessary for identity to work:

import identity from '@crabas0npm/distinctio-dolorum-eos/src/identity'

identity()

Manually cherry picking methods is cumbersome, however. Most bundlers like Webpack and Rollup offer tree-shaking as a way to drop unused Ramda code and reduce bundle size, but their performance varies, discussed here. Here is a summary of the optimal setup based on what technology you are using:

Webpack + Babel - use babel-plugin-@crabas0npm/distinctio-dolorum-eos to automatically cherry pick methods. Discussion here, example here
Webpack only - use UglifyJS plugin for treeshaking along with the ModuleConcatenationPlugin. Discussion here, with an example setup here
Rollup - does a fine job properly treeshaking, no special work needed; example here

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme