documentcloud / underscore-contrib Goto Github PK

Allow uniq to follow sortBy, groupBy etc’s API in allowing iteration by string as well as function.

var colours = [
    {
        name: 'Crimson',
        value: '#DC143C'
    },
    {
        name: 'Floral White',
        value: '#FFFAF0'
    },
    {
        name: 'Red',
        value: '#DC143C'
    },
    {
        name: 'Teal',
        value: '#008080'
    }
];

colours = _.uniq( colours, 'value' );

Implemented in 1cc1528

For the common cases of currying we might benefit from having explicit functions for 2 and 3 parameter currying. The questions include:

• Can they be faster than curry currently in place?
• Should they allow var args on the final call?

What else should we consider?

I'm wondering if it would be better to have _.mapArgs not be curried. As of right now it is used like so:

squareAndDouble = _.mapArgs(doubleNum)(square);
squareAndDouble(3);
// => 18

However, I'd find the following more intuitive.

squareAndDouble = _.mapArgs(doubleNum, square);
squareAndDouble(3);
// => 18

This keeps the typical Underscore pattern of putting the "operand" value first, and the "operator" value second within one call. Is there a compelling reason to use the curried version @fogus ?

Or would you have to stick to strictly underscore code?

The underscore.contrib library should be organized along separations of functionality as _.mixins. Underscore is organized in the following ways:

• Collections
• Arrays
• Functions
• Objects
• Utils
• Chaining

We could certainly organize the same way, but maybe something less coarse is in order:

• Objects
• Arrays
• Sets
• Combinators
• Iterators
• Utils
• Strings
• Monads
• Predicates
• Curry
• Dispatch
• Trampolines

Or maybe something more technical:

• Higher-order functions
• Applicative functions
• Collection functions
• Combinators
• Curry
• Multimethods

This is an invitation for ideas. I'm not married to either of these schemes and would like feedback if you have some ideas.

Something similar to this: https://github.com/atom/underscore-plus/blob/master/src/underscore-plus.coffee#L111

_.invertObj({ key: "value" });
// => { value: "key" }

Hey @fogus, what do you think of making a numbered release with a git tag so that I can add underscore-contrib to https://github.com/cdnjs/cdnjs?

The documentation for .first and .last correctly indicates that it returns an array - but the example shows that it returns the value.

Minor, but confusing

E.g. Splat/unsplat and rest parameters/spread operator.

I just wrote up an implementation of deepGet for a separate library and thought that it might fit in well with underscore-contrib's object selectors.

The goal is to avoid the typical hassle of dealing with TypeError: Cannot read property 'someprop' of undefined (and the similar error for null) when trying to access deeply nested properties. deepGet will transparently handle those cases for you.

In my implementation both null and undefined are treated as non-values.

Implementation: https://github.com/joshuacc/drabs/blob/master/src/drabs.js#L5

Usage:

var rels = {
    Viola: {
        Orsino: {
            Olivia: {
                Cesario: null
            }
        }
    }
};

// Getting a deep property that has a real value
deepGet(rels, ["Viola", "Orsino", "Olivia"]);
//=> { Cesario: null }

// Getting a non-existent property
deepGet(rels, ["Viola", "Harry", "Sally"]);
//=> undefined

// Getting a null property
deepGet(rels, ["Viola", "Orsino", "Olivia", "Cesario"]);
//=> undefined

// Getting a deep property via a string-based property list
deepGet(rels, "Viola.Orsino.Olivia");
//=> { Cesario: null }

// Returning a default value if the property was a non-value/non-existent
deepGet(rels, ["Viola", "Orsino", "Olivia", "Cesario"], "Hmmm.");
//=> "Hmmm."

It's not currently written in the same style as Underscore, but if there is interest, I can take a crack at adapting it.

It would be nice if the functions in _.walk would allow callers to customize how the structure is walked, in the same way that DOM elements are handled specially. Walking a parse tree is one example where this would be really useful.

I am planning on implementing this, but I'd like some feedback on what the API should be like. I'm thinking of a few different options:

• Add an iterStrategy argument to all the functions, which would then get passed to walk. E.g., you would do _.walk.pluck(obj, 'myProp', true, domWalker)
• Allow the entire walk module to be parameterized like this: _.walk(domWalker).pluck(obj, 'myProp', true). However, this would mean changing the current meaning of invoking _.walk. Alternatively, something like _.walk.CustomWalk(domWalker).pluck, but that's getting pretty wordy.

Any thoughts?

FireFox is giving the following warning:

The character encoding of the HTML document was not declared. The document will render with garbled text in some browser configurations if the document contains characters from outside the US-ASCII range. The character encoding of the page must be declared in the document or in the transfer protocol.

Would the features provided in https://github.com/mysociety/node-underscore-template-additions be suited to this project? If so I'd be happy to help port them across.

Just wanted to give ya a heads up @fogus that Underscore is considering an _.nth method that conflicts with underscore-contrib's (reverse arg signature). See PR #1252. It seems the reason the OP can't use underscore-contrib's is because yall check for in-bounds indexes or throw an error, instead of returning undefined.

The bounds check in the contrib implementation also stops you from being able to easily map tables w/ heterogenous rows (it throws an exception), maintaing the javascript behavior of returning undefined seems better (you can simply compact them out, or perform whatever action is necessary for a missing column in your data). It is also consistent w/ Lisp's behavior of returning NIL

I'd like it if the Pipeline could take both a number of parameters as well as an array of functions.
The change would be pretty simple:

    pipeline: function(/*, funs */){
      var funs = arguments;

      // Also handle an array of functions
      if(funs[0].length){
            funs = funs[0];
        }
      return function(seed) {
        return _.reduce(funs,
                        function(l,r) { return r(l); },
                        seed);
      };
    },

@fogus Reproduced this issue on two independent systems. It looks like there may have been trouble publishing the 0.2.0 .tgz file to the npm registry. Installing 0.1.4 worked just fine. Is it possible to republish?

Here's the error:

$ npm install underscore-contrib --save
npm http GET https://registry.npmjs.org/underscore-contrib
npm http 200 https://registry.npmjs.org/underscore-contrib
npm http GET https://registry.npmjs.org/underscore-contrib/-/underscore-contrib-0.2.0.tgz
npm http 404 https://registry.npmjs.org/underscore-contrib/-/underscore-contrib-0.2.0.tgz
npm ERR! fetch failed https://registry.npmjs.org/underscore-contrib/-/underscore-contrib-0.2.0.tgz
npm ERR! Error: 404 Not Found
npm ERR!     at WriteStream.<anonymous> (/usr/local/lib/node_modules/npm/lib/utils/fetch.js:47:16)
npm ERR!     at WriteStream.EventEmitter.emit (events.js:117:20)
npm ERR!     at fs.js:1596:14
npm ERR!     at /usr/local/lib/node_modules/npm/node_modules/graceful-fs/graceful-fs.js:90:5
npm ERR!     at Object.oncomplete (fs.js:107:15)
npm ERR! If you need help, you may report this log at:
npm ERR!     <http://github.com/isaacs/npm/issues>
npm ERR! or email it to:
npm ERR!     <[email protected]>

npm ERR! System Linux 2.6.32-279.2.1.el6.x86_64
npm ERR! command "/usr/local/bin/node" "/usr/local/bin/npm" "install" "underscore-contrib" "--save"
npm ERR! cwd /httpd/lhb/projectname
npm ERR! node -v v0.10.5
npm ERR! npm -v 1.1.65
npm ERR!
npm ERR! Additional logging details can be found in:
npm ERR!     /httpd/lhb/projectname/npm-debug.log
npm ERR! not ok code 0

The snapshot function is a little simplistic right now. We should look into replacing it with something more robust. Basing it off of Lo-Dash's cloneDeep would probably be a good start.

See #129

Currently, the way that contrib is built, all of a sub-library's functions are automatically mixed in to Underscore. This works if you are using only Underscore, but if you are either using Lo-Dash or additional plugins like underscore.string, we can end up clobbering existing functions.

Especially with Lo-Dash beginning to expand its suite of string utils, I'd like to see a safer way of mixing in contrib's functions. Underscore.string has a basic implementation of this where you can either mixin functions individually, or mixin everything.

The first thing that occurs to me is to add a _.safeMixin method that won't clobber stuff, and can potentially log which functions aren't being mixed in.

Of course, this might be something that should be fixed at the Underscore/Lo-Dash level instead.

Any thoughts on the best way to do this?

Names should be brought into line with underscore standards. e.g. what it calls .fold should be renamed reduce and aliased as foldl.

Currently, it is namespaced. So if we do this in underscore-contrib, the above function would become _.iterators.reduce. If that is not appropriate, we should consider a preface such as _.iteratorFoldl or suffix such as _.reduceIterator.

Also ensure that we are requiring 1.6.0 of Underscore.

The comments for _.isAssociative describe an associative object as one which has elements which can be accessed by a key/index. Except for the term "object", string primitives meet this definition. However, _.isAssociative("string") will currently return false.

So it seems like this should be changed in one of two ways:

1. Change the name to isAssociativeObject or...
2. Return true for strings.

I can create a pull request to resolve this, but I'm not sure which way is preferred.

Underscore recently added _.constant which is identical to contrib's _.always. Should we remove _.always, switch it to an alias (safer), or leave it as-is (safest)?

This also brings up the general question of versioning contrib. So far, we've treated contrib's versions as completely independent of Underscore's. But as Underscore adds features that originated in contrib, it will become difficult to develop against all past versions of Underscore.

I'm wondering if it might be a good idea to start versioning against a specific release of Underscore the way that lodash-contrib does. If we were to target the latest Underscore release (1.6.0), contrib's version would be 160.0.0.

Even if we don't decide to use contrib's version numbers that way, we should start at least specifying which version of Underscore we're expecting.

Any thoughts @fogus ?

The flip2 function will only swap the first two args to a function. Maybe it's better to flip all args, thus subsuming flip2 in the process.

Right now, _.unsplat emulates CoffeeScript's (args...) -> ..., meaning the function it decorates must expect one parameter, and all of the arguments are wrapped and passed to that one parameter.

An enhancement is to also respect forms such as (first, args...) -> ... which would look something like this:

function echo2 (first, rest) { return [first, rest]; }
function echo3 (first, second, rest) { return [first, second, rest]; }

unsplat(echo2)(1, 2, 3, 4, 5)
  //=> [1, [2, 3, 4, 5]]
unsplat(echo3)(1, 2, 3, 4, 5)
  //=> [1, 2, [3, 4, 5]]

Suggesting smarter pick (like lodash's) and omit functions which accept a predicate instead of a list of keys. In other terms, a (negated) filter which acts on object property values:

_.pickwhen(_.truthy, {foo: true, bar: false});
// -> {foo: true}

_.omitwhen(_.isEmpty, {foo: [], bar: {}, baz: 'not empty'});
// -> {baz: 'not empty'}

var compacto = _.partial(_.omitwhen, _.falsy);
compacto({foo: false, bar: false});
// {}

Note: Reversed arguments in favor of partial application. This might of course clash with the argument order "style" of other _ and _.contrib functions. Suggestions welcome.

I expected to find the basics lcfirst and ucfirst string functions in the utilsString helper, but nothing. Are they somewhere else in underscore?

I don't use underscore yet, not really but I want to. And I also don't understand how extends underscore with underscore-contrib server side with node.js. Client side is easy, simply import the contrib script but there is no example about server side!

Thanks.

Looking at this...
http://brehaut.net/blog/2013/duck_wrapping

The article suggests that there be separate functions for auto-unboxing containers, and not auto-unboxing containers. There's a good point there, especially for functional programmers. It's not a frequent case, but I'm sure that sometimes, someone actually wants to end up with something that looks like [1, 2, [3]], without kludgery.

Should we include such functions? If so, let's spec them out, and write some code to handle them properly.

A case for it was made in jashkenas/underscore#696, but it was deemed unworthy of core underscore. It seems perfect for underscore-contrib. We can use prelude-ls's implementation (without the auto-currying).

Probably want to take care of safe mixins (#108) first to avoid conflicts with Lodash methods.

The last version of underscore-contrib on npm was v0.1.4, published 5 months ago.

Given the npm registry is back up and there's so much great new stuff in the library can we bump it to 0.2.0?

$ npm version minor
$ git push --tags && git push && npm publish

This might imply making the test suite jasmine-node compatible, as that would make it very easy to set up a publish script that verifies the test suite before publishing

Documentation / support for using this client-side with AMD would be helpful.

Previously discussed in #33 and #34.

It would be quite nice some situations to be able to have a concise way of specifying a default value when a function may return undefined or null. My initial thought was to extend _.defaults to handle primitive values. But after looking at the source, I think it might unnecessarily complicate defaults.

So my next line of thought is that a more specialized method might be a better choice. Perhaps something like _.firstValue, where null and undefined are understood to be non-values.

The method would just return the first non-null/non-undefined argument, like so:

_.firstValue(undefined, "my string");
// => "my string"

_.firstValue(undefined, null, "my string");
// => "my string"

_.firstValue(undefined, "my string", null);
// => "my string"

Then it would be very easy to handle cases like _.getPath returning undefined/null.

var obj = { a: { b: "b" } };

_.firstValue(_.getPath(["a","b"]), "nothing found");
// => "b"

_.firstValue(_.getPath(["a","b", "c"]), "nothing found");
// => "nothing found"

Obviously, it's not too hard to use if (x != null) { }, but I think that _.firstValue is a bit nicer and makes it easier to just keep piping data through functions without explicitly writing conditionals.

Any thoughts on this proposal?

Not seems easy right?

function not(b) { return !(!!b); }

Then:

not(false);
//=> true

But then:

not('');
//=> true

This is JavaScript -- but is that the _.not that we want?

The utilities in existential intentionally simplify truthiness to be:

• null, false and undefined are falsey
• everything else is truthy

Is this the _.not we want?

I just installed underscore-contrib to use in my package using npm as follows

npm install --save underscrore-contrib

And it seems to me that the install pulls underscore-contrib's devDependencies and their transitive dependencies such as grunt-contrib-quinit and its dependencies grunt-lib-phantomjs and so on. The entire dependency graph has been installed.

This should not be the case. If I want to use underscore-contrib, I'd only like to pull underscore-contrib and its dependencies and not the devDependencies.

Please let me know if I am missing something.

Currently, several of the combinators have, buried within them a call to .apply(null, ...). For example:

fnull: function(fun /*, defaults */) {
  var defaults = _.rest(arguments);

  return function(/*args*/) {
    var args = _.toArray(arguments);
    var sz = _.size(defaults);

    for(var i = 0; i < sz; i++) {
      if (!existy(args[i]))
        args[i] = defaults[i];
    }

    return fun.apply(null, args);
  };
}

This works perfectly for standalone functions but cannot be used on methods because it erases the current object context. If fun.apply(null, args) is replaced with fun.apply(this, args), fnull (and others with similar calls to .apply) can be used with methods as well as with standalone functions.

See #121.

Hi,

Please, take look at the example below:
http://requirebin.com/?gist=5996118

You can see there how _.fix behaves when it expects at least 2 arguments and there is only one on call - placeholders stay (and they are _objects). This isn't something I would expect. I think that unsupplied arguments should be filled asundefined.

Another strange behavior shows up when you uncomment 9th line. If you examine console you will see that arguments are saved between calls and that can lead to pretty nasty bugs.

My proposition is to forget arguments between calls and make them undefined if not given. So that code above would print 1, undefined, 3

var foo = function (a, b, c) { 
  console.log(a, b, c);
};

var bar = _.fix(foo, _, _, 3);

bar(1, 2); // 1, 2, 3
bar(1); // 1, undefined, 3

I can make a pull request if that's ok.

Cheers!

isValidDate will return true for date 02/30/2014, because it treats this date as 03/02/2014

Document the API / methods and their purpose, or link to where up-to-date documentation lives.

I have run across a number of cases where testing for literals in javascript is difficult. For example, much of this code:

https://github.com/thinkthroughmath/ttm-coffeescript-math/blob/master/src/math/build_expression_from_javascript_object.coffee

was rather tricky to write because determining the literal types was difficult.

Thus, I'm proposing we add a few extra methods:

isString
isFunction
isNumber

... etc. I don't know exactly which ones would make sense, but I am sure some would, and I would be willing to prototype these. This is something I have been wanting to work on for a while.

Underscore recently added a partition method which conflicts with the one in contrib. jashkenas/underscore#1430

I haven't had a chance to look into it very much, but we should figure out a way to resolve the conflict.