feat: Permissive parsing in *_horiztonal

Threw in some tests for hashing as well

Author: dangotbanned

narwhals/_plan/demo.py

@@ -95,33 +95,33 @@ def sum(*columns: str) -> DummyExpr:
     return col(columns).sum()
 
 
-def all_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def all_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return boolean.AllHorizontal().to_function_expr(*it).to_narwhals()
 
 
-def any_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def any_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return boolean.AnyHorizontal().to_function_expr(*it).to_narwhals()
 
 
-def sum_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def sum_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return F.SumHorizontal().to_function_expr(*it).to_narwhals()
 
 
-def min_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def min_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return F.MinHorizontal().to_function_expr(*it).to_narwhals()
 
 
-def max_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def max_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return F.MaxHorizontal().to_function_expr(*it).to_narwhals()
 
 
-def mean_horizontal(*exprs: DummyExpr | t.Iterable[DummyExpr]) -> DummyExpr:
-    it = (expr._ir for expr in flatten(exprs))
+def mean_horizontal(*exprs: IntoExpr | t.Iterable[IntoExpr]) -> DummyExpr:
+    it = parse.parse_into_seq_of_expr_ir(*exprs)
     return F.MeanHorizontal().to_function_expr(*it).to_narwhals()
 
 

tests/plan/expr_parsing_test.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from typing import Callable
 from typing import Iterable
 
 import pytest
 
 import narwhals as nw
 import narwhals._plan.demo as nwd
+from narwhals._plan import boolean
+from narwhals._plan import functions as F  # noqa: N812
 from narwhals._plan.common import ExprIR
+from narwhals._plan.common import Function
+from narwhals._plan.dummy import DummyExpr
+from narwhals._plan.expr import FunctionExpr
 
 if TYPE_CHECKING:
     from narwhals._plan.common import IntoExpr
@@ -35,3 +41,42 @@ def test_parsing(
     assert all(
         isinstance(node, ExprIR) for node in nwd.select_context(*exprs, **named_exprs)
     )
+
+
+@pytest.mark.parametrize(
+    ("function", "ir_node"),
+    [
+        (nwd.all_horizontal, boolean.AllHorizontal),
+        (nwd.any_horizontal, boolean.AnyHorizontal),
+        (nwd.sum_horizontal, F.SumHorizontal),
+        (nwd.min_horizontal, F.MinHorizontal),
+        (nwd.max_horizontal, F.MaxHorizontal),
+        (nwd.mean_horizontal, F.MeanHorizontal),
+    ],
+)
+@pytest.mark.parametrize(
+    "args",
+    [
+        ("a", "b", "c"),
+        (["a", "b", "c"]),
+        (nwd.col("d", "e", "f"), nwd.col("g"), "q", nwd.nth(9)),
+        ((nwd.lit(1),)),
+        ([nwd.lit(1), nwd.lit(2), nwd.lit(3)]),
+    ],
+)
+def test_function_expr_horizontal(
+    function: Callable[..., DummyExpr],
+    ir_node: type[Function],
+    args: Seq[IntoExpr | Iterable[IntoExpr]],
+) -> None:
+    variadic = function(*args)
+    sequence = function(args)
+    assert isinstance(variadic, DummyExpr)
+    assert isinstance(sequence, DummyExpr)
+    variadic_node = variadic._ir
+    sequence_node = sequence._ir
+    unrelated_node = nwd.lit(1)._ir
+    assert isinstance(variadic_node, FunctionExpr)
+    assert isinstance(variadic_node.function, ir_node)
+    assert variadic_node == sequence_node
+    assert sequence_node != unrelated_node