enh: add (optional) `order_by` to `rolling_*`, `cum_*`, `first`, ...

[MarcoGorelli]

Currently, we don't allow

nw.col('price').cum_sum()

in the lazy case, requiring instead

nw.col('price').cum_sum().over(order_by='date')

We could also allow

nw.col('price').cum_sum(order_by='date')

with the following restriction:

• it's not allowed to do nw.col('price').cum_sum(order_by='date').over('asset', order_by='date'). specify order_by in either over or cum_sum but not both

What this enables:

• we can add order_by to first, so then we you can do df.group_by('a').agg(nw.col('b').first(order_by='c'))
• i think it's conceptually easier to teach nw.col('price').cum_sum(order_by='date') than it is to teach nw.col('price').cum_sum().over(order_by='date')

I'm just trying this out, but i think the impact on complexity is relatively small

Issues:

• slight divergence from Polars API, but I'm ok with it, i think it still feels in the polars spirit

[dangotbanned]

Isn't this just adding sort_by with a different spelling? 😅

More context

What I have in this test is where the sort_by would be for equivalence

narwhals/tests/plan/over_test.py

Lines 459 to 501 in 9b9122b

	def order_case(
	columns: ValueColumn | list[ValueColumn],
	aggregation: Agg,
	/,
	order_by: OrderColumn | Sequence[OrderColumn],
	*,
	descending: bool = False,
	nulls_last: bool = False,
	expected: NonNestedLiteral | list[NonNestedLiteral],
	) -> ParameterSet:
	"""Generate `Expr`s and an expected dataset for ordered aggregations.
	Covers both `over(order_by=...)` and `sort_by(...)` to ensure their results are identical in a
	select context.
	"""
	# Encoding argument combinations into column names and the shared test id
	ordering = f"{order_by}-{'desc' if descending else 'asc'}-{'nulls_last' if nulls_last else 'nulls_first'}"
	suffix_over = f"_{aggregation}-over-{ordering}"
	suffix_sort_by = f"_sort_by-{ordering}-{aggregation}"
	test_id = f"{columns}_{aggregation}-{ordering}"
	# Generating what our expected dataset should be
	names_values = list(zip_strict(_ensure_list(columns), _ensure_list(expected)))
	result_data = {
	f"{name}{suffix}": [expect]
	for suffix in (suffix_over, suffix_sort_by)
	for name, expect in names_values
	}
	# Finally, all the expressions
	cols = nwp.col(columns)
	agg = _AGG_EXPR_METHOD[aggregation]
	over = (
	cols.pipe(agg)
	.over(order_by=order_by, descending=descending, nulls_last=nulls_last)
	.name.suffix(suffix_over)
	)
	sort_by = (
	cols.sort_by(order_by, descending=descending, nulls_last=nulls_last)
	.pipe(agg)
	.name.suffix(suffix_sort_by)
	)
	return pytest.param([over, sort_by], result_data, id=test_id)

• The signatures of all the Expr methods can stay the same
• The implementations can just peek behind for the order
• It would naturally support descending and nulls_last
  • Which I imagine would be the next ask after adding order_by: str | Sequence[str]

[MarcoGorelli]

it would be kind of like adding sort_by but imposing that it be followed by cum_sum / first / ...