chore: Simplify spark-like and ibis concat_str (#3240)

* spark-like

* ibis

* is it pyarrow?

---------

Co-authored-by: Marco Edward Gorelli <[email protected]>

Author: FBruzzesi

narwhals/_ibis/namespace.py

@@ -83,12 +83,14 @@ def func(df: IbisLazyFrame) -> list[ir.Value]:
             cols = chain.from_iterable(expr(df) for expr in exprs)
             cols_casted = [s.cast("string") for s in cols]
 
-            if not ignore_nulls:
-                result = cols_casted[0]
-                for col in cols_casted[1:]:
-                    result = result + separator + col
-            else:
+            if ignore_nulls:
                 result = lit(separator).join(cols_casted)
+            else:
+                result = reduce(
+                    lambda acc, col: acc.concat(separator, col),
+                    cols_casted[1:],
+                    cols_casted[0],
+                )
 
             return [result]
 

narwhals/_spark_like/namespace.py

@@ -2,6 +2,7 @@
 
 import operator
 from functools import reduce
+from itertools import chain
 from typing import TYPE_CHECKING, Any
 
 from narwhals._expression_parsing import (
@@ -19,7 +20,6 @@
 )
 from narwhals._sql.namespace import SQLNamespace
 from narwhals._sql.when_then import SQLThen, SQLWhen
-from narwhals._utils import zip_strict
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -173,37 +173,13 @@ def concat_str(
         self, *exprs: SparkLikeExpr, separator: str, ignore_nulls: bool
     ) -> SparkLikeExpr:
         def func(df: SparkLikeLazyFrame) -> list[Column]:
-            cols = [s for _expr in exprs for s in _expr(df)]
-            cols_casted = [s.cast(df._native_dtypes.StringType()) for s in cols]
-            null_mask = [df._F.isnull(s) for s in cols]
+            F = self._F
+            cols = tuple(chain.from_iterable(e(df) for e in exprs))
+            result = F.concat_ws(separator, *cols)
 
             if not ignore_nulls:
-                null_mask_result = reduce(operator.or_, null_mask)
-                result = df._F.when(
-                    ~null_mask_result,
-                    reduce(
-                        lambda x, y: df._F.format_string(f"%s{separator}%s", x, y),
-                        cols_casted,
-                    ),
-                ).otherwise(df._F.lit(None))
-            else:
-                init_value, *values = [
-                    df._F.when(~nm, col).otherwise(df._F.lit(""))
-                    for col, nm in zip_strict(cols_casted, null_mask)
-                ]
-
-                separators = (
-                    df._F.when(nm, df._F.lit("")).otherwise(df._F.lit(separator))
-                    for nm in null_mask[:-1]
-                )
-                result = reduce(
-                    lambda x, y: df._F.format_string("%s%s", x, y),
-                    (
-                        df._F.format_string("%s%s", s, v)
-                        for s, v in zip_strict(separators, values)
-                    ),
-                    init_value,
-                )
+                null_mask = reduce(operator.or_, (F.isnull(s) for s in cols))
+                result = F.when(~null_mask, result).otherwise(F.lit(None))
 
             return [result]