docs: emphasize lambda terminology, trim skill lambda section

Lead user-facing array-lambda docs with "lambda function" instead of
"higher-order function," which is less recognizable to users. Drop the
alias list, serialization caveat, and DuckDB-dialect note from the skill
to keep it lean; those details already live in the docstrings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: timsaucer

docs/source/user-guide/common-operations/expressions.rst

@@ -145,15 +145,16 @@ This function returns a new array with the elements repeated.
 
 In this example, the `repeated_array` column will contain `[[1, 2, 3], [1, 2, 3]]`.
 
-Higher-order functions and lambdas
-----------------------------------
+Lambda functions
+----------------
 
-Some array functions are *higher-order*: they take a lambda that runs once per
-element. :py:func:`~datafusion.functions.array_transform` maps a lambda over
+Some array functions take a *lambda function*: a small function that runs once
+per element. :py:func:`~datafusion.functions.array_transform` maps a lambda over
 every element, :py:func:`~datafusion.functions.array_filter` keeps the elements
 for which a predicate lambda is true, and
 :py:func:`~datafusion.functions.array_any_match` returns whether any element
-satisfies a predicate lambda.
+satisfies a predicate lambda. (Functions that take another function as an
+argument are sometimes called *higher-order* functions.)
 
 The simplest way to supply a lambda is a Python ``lambda``. Its parameter names
 become the lambda parameters, and its return value becomes the body.

skills/datafusion_python/SKILL.md

@@ -488,32 +488,24 @@ col("array_col")[0]                  # access array element (0-indexed)
 col("array_col")[1:3]                # array slice (0-indexed)
 ```
 
-### Higher-Order Array Functions (Lambdas)
+### Lambda Functions
 
-Some array functions take a lambda that runs once per element. Pass a Python
-`lambda` directly — its parameter names become the lambda parameters and its
-return value becomes the body:
+Some array functions take a lambda function that runs once per element. Pass a
+Python `lambda` directly — its parameter names become the lambda parameters and
+its return value becomes the body:
 
 ```python
 F.array_transform(col("a"), lambda v: v * 2)    # map: [1,2,3] -> [2,4,6]
 F.array_filter(col("a"), lambda v: v > 2)        # filter: [1,2,3] -> [3]
 F.array_any_match(col("a"), lambda v: v > 3)     # predicate: any element > 3
 ```
 
-Aliases: `list_transform` for `array_transform`; `list_filter` for
-`array_filter`; `any_match` / `list_any_match` for `array_any_match`.
-
 For explicit parameter names, build the lambda by hand:
 
 ```python
 F.array_transform(col("a"), F.lambda_(["v"], F.lambda_var("v") * lit(2)))
 ```
 
-Limitations: lambda expressions cannot be serialized (`Expr.to_bytes` / pickle
-raise `Lambda not implemented`). SQL lambda syntax (`x -> x * 2`) needs the
-DuckDB dialect (`SessionConfig().set("datafusion.sql_parser.dialect", "DuckDB")`);
-the Python builder above is dialect-independent.
-
 ## SQL-to-DataFrame Reference
 
 | SQL | DataFrame API |