fixes #349: add _.partition function

index.html

@@ -233,6 +233,7 @@
       <li>- <a href="#compact">compact</a></li>
       <li>- <a href="#flatten">flatten</a></li>
       <li>- <a href="#without">without</a></li>
+      <li>- <a href="#partition">partition</a></li>
       <li>- <a href="#union">union</a></li>
       <li>- <a href="#intersection">intersection</a></li>
       <li>- <a href="#difference">difference</a></li>
@@ -432,7 +433,7 @@ <h2 id="collections">Collection Functions (Arrays or Objects)</h2>
           array-like objects such as</i> <tt>arguments</tt>, <tt>NodeList</tt><i>
           and similar. But it works by duck-typing, so avoid passing objects with
           a numeric <tt>length</tt> property. It's also good to note that an
-          <tt>each</tt> loop cannot be broken out of — to break, use <b>_.find</b> 
+          <tt>each</tt> loop cannot be broken out of — to break, use <b>_.find</b>
           instead.
         </i>
       </p>
@@ -841,6 +842,17 @@ <h2 id="arrays">Array Functions</h2>
       <pre>
 _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 =&gt; [2, 3, 4]
+</pre>
+
+      <p id="partition">
+        <b class="header">partition</b><code>_.partition(array, predicate)</code>
+        <br />
+        Split <b>array</b> into two arrays: one whose elements all satisfy
+        <b>predicate</b>, and one whose elements all do not satisfy <b>predicate</b>.
+      </p>
+      <pre>
+_.partition([0, 1, 2, 3, 4, 5], function(e) { return isOdd(e); });
+=&gt; [[1, 3, 5], [0, 2, 4]]
 </pre>
 
       <p id="union">

test/arrays.js

@@ -82,6 +82,16 @@ $(document).ready(function() {
     ok(_.without(list, list[0]).length == 1, 'ditto.');
   });
 
+  test("partition", function() {
+    var list = [0, 1, 2, 3, 4, 5];
+    function inspect(x) { return x instanceof Array ? '[' + _.map(x, inspect) + ']' : '' + x; }
+    equal(inspect(_.partition(list, function(x) { return x < 4; })), '[[0,1,2,3],[4,5]]', 'handles bool return values');
+    equal(inspect(_.partition(list, function(x) { return x & 1; })), '[[1,3,5],[0,2,4]]', 'handles 0 and 1 return values');
+    equal(inspect(_.partition(list, function(x) { return x - 3; })), '[[0,1,2,4,5],[3]]', 'handles other numeric return values');
+    equal(inspect(_.partition(list, function(x) { return x > 1 ? null : true; })), '[[0,1],[2,3,4,5]]', 'handles null return values');
+    equal(inspect(_.partition(list, function(x) { if(x < 2) return true; })), '[[0,1],[2,3,4,5]]', 'handles undefined return values');
+  });
+
   test("uniq", function() {
     var list = [1, 2, 1, 3, 1, 4];
     equal(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');

underscore.js

@@ -460,6 +460,16 @@
     return _.difference(array, slice.call(arguments, 1));
   };
 
+  // Split an array into two arrays: one whose elements all satisfy the given
+  // predicate, and one whose elements all do not satisfy the predicate.
+  _.partition = function(array, predicate) {
+    var pass = [], fail = [];
+    each(array, function(elem) {
+      (predicate(elem) ? pass : fail).push(elem);
+    });
+    return [pass, fail];
+  };
+
   // Produce a duplicate-free version of the array. If the array has already
   // been sorted, you have the option of using a faster algorithm.
   // Aliased as `unique`.