I still think Array#partition will be great as well

[MaxGraey]

Original proposal: tc39/proposal-array-filtering#2

Ofc with groupBy we could be emulate partition as:

function partition(arr, fn) {
  return Object.values(arr.groupBy(idx => Number(!fn(idx))));
}

or

function partition(arr, fn) {
  return Object.assign([], arr.groupBy(idx => Number(!fn(idx))));
}

But why not just present it as a first class citizen?

[ljharb]

Returning a keyed object is much cleaner than spitting out a tuple of values (your emulation doesn’t sort the object keys, btw), from an api design perspective.

[MaxGraey]

your emulation doesn’t sort the object keys, btw

This is another reason that it would be nice to have a correct method. Returning a tuple in combination with a destructive operation is much more convenient if we have only group of two values:

const { true: a, false: b } = arr.groupBy(x => x > 2);

vs

const [a, b] = arr.partition(x => x > 2);

[ljharb]

In that example though, should the trues or the falses come first? I believe many languages do it differently.

[MaxGraey]

I believe many languages do it differently.

That's doesn't matter. I'm just demonstrating ergonomics

[ljharb]

It matters if it means we couldn’t come up with a result that was consistently intuitive - in other words, if the order isn’t intuitive, it is thus far less ergonomic.

[MaxGraey]

I believe many languages do it differently.

Btw I'm not sure about this. Here Scala example:

val x = List(15, 10, 5, 8, 20, 12)
val (a, b) = x.partition(_ > 10)

> a: List[Int] = List(15, 20, 12)
> b: List[Int] = List(10, 5, 8)

Btw Scala also have groupBy and also span and splitAt

[dartess]

In that example though, should the trues or the falses come first? I believe many languages do it differently.

Trues first. We can see the related links in the original issue.

Implementation in other languages:

• Scala (prev comment)
• OCaml
• Haskell
• Kotlin

Implementation in JS libs:

• RxJS
• Underscore
• Lodash
• Ramda

The first list is for the true predicate. The second is for the false. Valid for all the examples. It seems intuitive to me. We "separate the wheat from the chaff". Can you give an example of languages or libraries where this method is implemented the other way around?

[dartess]

One more thought.

Of course, this will not be a weighty argument, but still I would like to add it.

When using a typescript, we can use typeguards as a predicate. This will allow for easy separation of types, which (as it seems to me) cannot be done through a groupBy.

Example

[MaxGraey]

Another argument for addision partition method is that runtimes can be much more efficient with it, since the result is always a tuple of two elements unlike groupBy which return an object with an unknown number of entries.

[theScottyJam]

I'm going to try and brainstorm a couple of ways in which we could make it clear whether "true" means first or second element of array. Not that any of these ideas are any good, I'm mostly just thinking outloud.

We could have "partition" act like "groupBy", except it inserts results into an array instead of an object.

const [minors, adults] = users.partition(user => user.age >= 18 ? 1 : 0)
const [minors, adults] = users.partition(user => Number(user.age >= 18))
const [minors, adults] = users.partition(user => user.age >= 18) // Possible if the result is auto-coerced into a number. But, this would cause partition() to behave backwards from any other language.
const [infants, oneYearOlds, twoYearOlds, ...] = users.partition(user => user.age)

We could try and find a different name for "partition" that indicates the ordering:

// Horrible name, but the ordering is right in the name
const [adults, minors] = users.trueFalseGrouping(user => user.age >= 18)

// Maybe ...
const [adults, minors] = users.selectOrReject(user => user.age >= 18)

I'm also perfectly happy with just doing this:

const { true: adults, false: minors } = users.groupBy(user => user.age >= 18)

For how often I need a partition behavior like this, just using groupBy seems simple enough, and it's very readable for everyone else looking at the code.

I'd note that it would be a little ironic if we chose to introduce the partition method with this kind of ambiguity when this whole repo originated because of an attempt to provide an alternative filter method name that was less ambiguous than "filter".

[jridgewell]

Maybe @rbuckton could weigh in on whether groupBy can be easily typed to provide a similar experience as #9 (comment).

[bakkot]

Can you give an example of languages or libraries where this method is implemented the other way around?

Swift, but it's the only one I know of. true-first is a very firm precedent for people coming from other languages.

I still think const { true: a, false: b } = arr.groupBy(x => x > 2); is clearer, though, since it does not require readers to know this non-obvious fact.

[dartess]

@bakkot The Swift's partition only changes the order of the elements, and does not divide into two lists. This is closer to sorting than grouping.