ramda - npm Package Compare versions

ramda

Package Overview

Dependencies

Maintainers

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.8.0 to 0.9.0

CONTRIBUTING.md

dist/ramda.js

dist/ramda.min.js

jsdoc-template/docs.html.handlebars

jsdoc-template/index.html.handlebars

jsdoc-template/publish.js

less/card.less

less/hljs.less

less/layout.less

less/ramda.less

less/sidebar.less

less/variables.less

src/__.js

src/add.js

src/all.js

src/allPass.js

src/always.js

src/and.js

src/any.js

src/anyPass.js

src/ap.js

src/append.js

src/appendTo.js

src/apply.js

src/arity.js

src/assoc.js

src/assocPath.js

src/binary.js

src/bind.js

src/call.js

src/chain.js

src/charAt.js

src/charCodeAt.js

src/clone.js

src/commute.js

src/commuteMap.js

src/comparator.js

src/compose.js

src/concat.js

src/cond.js

src/construct.js

src/constructN.js

src/contains.js

src/containsWith.js

src/converge.js

src/countBy.js

src/createMapEntry.js

src/curry.js

src/curryN.js

src/dec.js

src/difference.js

src/differenceWith.js

src/divide.js

src/drop.js

src/dropWhile.js

src/empty.js

src/eq.js

src/eqDeep.js

src/eqProps.js

src/evolve.js

src/F.js

src/filter.js

src/filterIndexed.js

src/find.js

src/findIndex.js

src/findLast.js

src/findLastIndex.js

src/flatten.js

src/flip.js

src/foldl.js

src/foldlIndexed.js

src/foldr.js

src/foldrIndexed.js

src/forEach.js

src/forEachIndexed.js

src/fromPairs.js

src/func.js

src/functions.js

src/functionsIn.js

src/get.js

src/groupBy.js

src/gt.js

src/gte.js

src/has.js

src/hasIn.js

src/head.js

src/I.js

src/identity.js

src/ifElse.js

src/inc.js

src/indexOf.js

src/init.js

src/insert.js

src/insertAll.js

src/installTo.js

src/internal/_add.js

src/internal/_all.js

src/internal/_any.js

src/internal/_ap.js

src/internal/_append.js

src/internal/_baseCopy.js

src/internal/_checkForMethod.js

src/internal/_compareKeys.js

src/internal/_compose.js

src/internal/_concat.js

src/internal/_contains.js

src/internal/_containsWith.js

src/internal/_createComposer.js

src/internal/_createMaxMin.js

src/internal/_createMaxMinBy.js

src/internal/_createPartialApplicator.js

src/internal/_curry2.js

src/internal/_curry3.js

src/internal/_eqDeep.js

src/internal/_extend.js

src/internal/_filter.js

src/internal/_filterIndexed.js

src/internal/_foldl.js

src/internal/_forEach.js

src/internal/_functionsWith.js

src/internal/_gt.js

src/internal/_hasMethod.js

src/internal/_indexOf.js

src/internal/_isArray.js

src/internal/_isInteger.js

src/internal/_isThenable.js

src/internal/_keyValue.js

src/internal/_lastIndexOf.js

src/internal/_lt.js

src/internal/_makeFlat.js

src/internal/_map.js

src/internal/_multiply.js

src/internal/_noArgsException.js

src/internal/_nth.js

src/internal/_pairWith.js

src/internal/_path.js

src/internal/_pCompose.js

src/internal/_pickAll.js

src/internal/_pickBy.js

src/internal/_pluck.js

src/internal/_predicateWrap.js

src/internal/_prepend.js

src/internal/_satisfiesSpec.js

src/internal/_slice.js

src/intersection.js

src/intersectionWith.js

src/invert.js

src/invertObj.js

src/invoker.js

src/is.js

src/isArrayLike.js

src/isEmpty.js

src/isNil.js

src/isSet.js

src/join.js

src/keys.js

src/keysIn.js

src/last.js

src/lastIndexOf.js

src/length.js

src/lens.js

src/lift.js

src/liftN.js

src/lPartial.js

src/lt.js

src/lte.js

src/map.js

src/mapAccumL.js

src/mapAccumR.js

src/mapIndexed.js

src/mapObj.js

src/mapObjIndexed.js

src/match.js

src/mathMod.js

src/max.js

src/maxBy.js

src/memoize.js

src/min.js

src/minBy.js

src/mixin.js

src/modulo.js

src/multiply.js

src/nAry.js

src/negate.js

src/not.js

src/nth.js

src/nthArg.js

src/of.js

src/omit.js

src/once.js

src/op.js

src/or.js

src/partition.js

src/path.js

src/pathEq.js

src/pathOn.js

src/pCompose.js

src/pick.js

src/pickAll.js

src/pickBy.js

src/pipe.js

src/pluck.js

src/pPipe.js

src/prepend.js

src/prependTo.js

src/product.js

src/project.js

src/prop.js

src/propEq.js

src/propOf.js

src/propOr.js

src/props.js

src/range.js

src/reject.js

src/rejectIndexed.js

src/remove.js

src/repeat.js

src/replace.js

src/reverse.js

src/rPartial.js

src/scanl.js

src/slice.js

src/sort.js

src/sortBy.js

src/split.js

src/strIndexOf.js

src/strLastIndexOf.js

src/substring.js

src/substringFrom.js

src/substringTo.js

src/subtract.js

src/sum.js

src/T.js

src/tail.js

src/take.js

src/takeWhile.js

src/tap.js

src/times.js

src/toLower.js

src/toPairs.js

src/toPairsIn.js

src/toUpper.js

src/trim.js

src/type.js

src/unapply.js

src/unary.js

src/unfoldr.js

src/union.js

src/unionWith.js

src/uniq.js

src/uniqWith.js

src/unnest.js

src/useWith.js

src/values.js

src/valuesIn.js

src/where.js

src/wrap.js

src/xprod.js

src/zip.js

src/zipObj.js

src/zipWith.js

tasks/push-gh-pages.js

ext/impure/setProp.js

		var R = require('../..');

		var setProp = R.curry (function(prop, value, obj) {
		var setProp = R.curry(function(prop, value, obj) {
		obj[prop] = value;
		@@ -5,0 +5,0 @@ return obj;

ext/lazylist/lazylist.js

		@@ -139,3 +139,3 @@ (function(factory) {
		*/
		skip: function(n) {
		drop: function(n) {
		var skip = function(ctr, lz) {
		@@ -223,5 +223,5 @@ return (ctr <= 0) ? lz : skip(ctr - 1, lz.tail());
		* @example
		* R.repeat(1) //=> [1, 1, 1, ...]
		* R.lazylist.repeat(1) //=> [1, 1, 1, ...]
		*/
		R.repeat = function(value) {
		R.lazylist.repeat = function(value) {
		var fn = R.always(value);
		@@ -228,0 +228,0 @@ return lazylist(null, fn, fn);

LICENSE.txt

		The MIT License (MIT)

		Copyright (c) 2013 Scott Sauyet and Michael Hurley
		Copyright (c) 2013-2014 Scott Sauyet and Michael Hurley

		@@ -5,0 +5,0 @@ Permission is hereby granted, free of charge, to any person obtaining a copy

package.json

		@@ -27,3 +27,3 @@ {
		"description": "A practical functional library for JavaScript programmers.",
		"version": "0.8.0",
		"version": "0.9.0",
		"homepage": "https://www.github.com/ramda/ramda",
		@@ -35,4 +35,5 @@ "license": "MIT",
		},
		"main": "ramda.js",
		"main": "dist/ramda.js",
		"scripts": {
		"jshint": "grunt jshint",
		"test": "grunt test"
		@@ -42,18 +43,30 @@ },
		"devDependencies": {
		"acorn": "0.9.x",
		"benchmark": "~1.0.0",
		"commander": "2.5.x",
		"deedpoll": "0.2.x",
		"dox": "latest",
		"envvar": "1.x.x",
		"escodegen": "1.4.x",
		"gh-pages": "^0.2.0",
		"grunt": "~0.4.5",
		"grunt-benchmark": "https://github.com/buzzdecafe/grunt-benchmark/archive/09999a8c3fbfff04a1695846c1ccd0bd8a0ef5ab.tar.gz",
		"grunt-browserify": "3.2.1",
		"grunt-cli": "~0.1.13",
		"grunt-contrib-clean": "^0.6.0",
		"grunt-contrib-connect": "^0.8.0",
		"grunt-contrib-copy": "^0.7.0",
		"grunt-contrib-jshint": "~0.10.0",
		"grunt-contrib-less": "^1.0.0",
		"grunt-docco": "latest",
		"grunt-jscs": "~0.7.0",
		"grunt-jsdoc": "^0.6.0",
		"grunt-jscs": "1.2.x",
		"grunt-jsdoc": "^0.6.1",
		"grunt-mocha": "~0.4.11",
		"grunt-mocha-test": "~0.11.0",
		"grunt-saucelabs": "^8.3.1",
		"handlebars": "^2.0.0",
		"highlight.js": "^8.4.0",
		"js-yaml": "^3.2.5",
		"lodash": "latest",
		"marked": "^0.3.2",
		"orchestrate": "~0.3.4",
		@@ -60,0 +73,0 @@ "q": "^1.1.1",

136

README.md

		@@ -1,2 +0,2 @@
		Project Ramda
		Ramda
		=============
		@@ -8,36 +8,65 @@
		[![npm module](https://badge.fury.io/js/ramda.svg)](https://www.npmjs.org/package/ramda)
		[![dependencies](https://david-dm.org/ramda/ramda.png)](https://david-dm.org/ramda/ramda)
		[![dependencies](https://david-dm.org/ramda/ramda.svg)](https://david-dm.org/ramda/ramda)
		[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/ramda/ramda?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

		Goals
		-----

		Why Ramda?
		----------

		<img src="http://ramda.jcphillipps.com/logo/ramdaFilled_200x235.png"
		width="200" height="235" align="left" hspace="12" />
		Using this library should feel as much like using Javascript as
		possible. Of course it's functional Javascript, but we're not
		introducing lambda expressions in strings, we're not borrowing consed
		width="170" height="190" align="right" hspace="12" />

		There are already several excellent libraries with a functional flavor such as _Underscore_ and _Lo-Dash_. While they are meant to be general-purpose toolkits, suitable for working in multiple paradigms, we created Ramda differently. We wanted a library designed specifically for a functional programming style, one that made it easy to create functional pipelines, one that never mutated user data.


		What's Different?
		-----------------

		While Ramda includes all of the favorite list-manipulation functions you expect, e.g. `map`, `filter`, `reduce`, `find`, and so forth, Ramda is also significantly different from libraries like _Underscore_ and _Lo-Dash_.

		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.



		Also see [Why Ramda?](http://fr.umio.us/why-ramda/), [Why Curry Helps](http://hughfdjackson.com/javascript/why-curry-helps/) and [Hey Underscore, You're Doing It Wrong!](https://www.youtube.com/watch?v=m3svKOdZijA&app=desktop).


		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 will be normal Javascript objects, and our
		usual collections will be Javascript arrays. We will not try to reach
		the point where all the functions have only zero, one, or two arguments.
		We will certainly try to keep some of the normal features of Javascript
		that seem to be unusual in functional languages, including variable
		length function signatures and functions as objects with properties.
		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.

		Ramda will never be a drop-in replacement for Underscore (or LoDash, or
		even a drop-in-and-mechanically-switch-the-parameter-order-everywhere
		replacement.) It is intended to work with a different style of coding.
		While offering similar functionality, Ramda will never be a drop-in
		replacement for _Underscore_ / _Lo-Dash_. Ramda is intended to work with a
		different style of coding.

		Functional programming is in good part about immutable objects and
		side-effect free functions. While Ramda does not expect to do anything to
		enforce that style, its code should always work to make that style as
		frictionless as possible.
		side-effect free functions. While Ramda does not enforce this, it
		enables such style to be as frictionless as possible.

		As much as we can, we would like the implementation to be both clean and
		elegant. But the API is king: we will sacrifice a great deal of
		implementation elegance for even a slightly cleaner API.
		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.

		Unlike the developers of that silly-named _Eweda_ project, though, this
		one will focus also on performance, striving for a reliable and quick
		implementation over any notions of functional purity.
		Last but not least, Ramda strives for performance. A reliable and quick
		implementation wins over any notions of functional purity.

		@@ -74,3 +103,3 @@ Installation
		```html
		<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.8.0/ramda.min.js"></script>
		<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.9.0/ramda.min.js"></script>
		```
		@@ -81,4 +110,4 @@
		```html
		<script src="//cdn.jsdelivr.net/ramda/0.8.0/ramda.min.js"></script>
		<script src="//cdn.jsdelivr.net/ramda/0.8/ramda.min.js"></script>
		<script src="//cdn.jsdelivr.net/ramda/0.9.0/ramda.min.js"></script>
		<script src="//cdn.jsdelivr.net/ramda/0.9/ramda.min.js"></script>
		<script src="//cdn.jsdelivr.net/ramda/latest/ramda.min.js"></script>
		@@ -124,41 +153,3 @@ ```

		Structure
		---------

		### Automatic Currying ###

		The functions included should automatically allow for partial
		application without an explicit call to lPartial. Many of these operate
		on lists. A single list parameter should probably come last, which
		might conflict with the design of other libraries that have strong
		functional components (I'm looking at you Underscore!)

		The idea is that, if foldl has this signature:


		```javascript
		var foldl = function(fn, accum, arr) { /* ... */}
		```

		and we have this simple function:

		```javascript
		var add = function(a, b) {return a + b;};
		```

		then, instead of having to manually call lPartial like this:

		```javascript
		var sum = lPartial(foldl, add, 0);
		var total = sum([1, 2, 3, 4]);
		```

		with ramda, we can just do this:

		```javascript
		var sum = foldl(add, 0);
		var total = sum([1, 2, 3, 4]);
		```


		Running The Test Suite
		@@ -196,3 +187,3 @@ ----------------------

		If you have PhantomJS installed, you can run `testem -l phantomjs` to run the
		If you have _PhantomJS_ installed, you can run `testem -l phantomjs` to run the
		tests completely headlessly.
		@@ -204,12 +195,3 @@

		So What's With Eweda?
		---------------------

		The [eweda library](https://github.com/CrossEye/eweda) was written by
		the developers of this library, with similar goals. But that one strove
		more for implementation elegance than for practical capabilities. Ramda
		is all about giving users real-world tools. Eweda can be seen more as
		an academic excercise, mostly proving out what does and doesn't work, and
		doing so as elegantly as possible.

		Acknowledgements
		@@ -216,0 +198,0 @@ -----------------

ext/random/random.js

ext/types/Either.js

ext/types/Future.js

ext/types/Identity.js

ext/types/IO.js

ext/types/Maybe.js

ext/types/Reader.js

ramda.js

ramda.min.js

New alerts

Improved metrics

Worsened metrics