fix(python): address unexpected expression name from use of unary - or + operators

[alexander-beedie]

Closes #11149.

Because we implement -expr as lit(0) - expr (and +expr as lit(0) + expr) the output name of the resulting expressions is literal. While this makes sense (leftmost expr naming convention), it is not something that the caller expects as this is an internal detail that they know nothing about (and shouldn't have to read the source to discover ;)

In accordance with "the principle of least surprise", this PR maintains the expected name, as determined from the rhs expr (via meta.output_name), and not the anonymous/internal lhs lit. As well as resulting in the expected name for a single op, this also ensures that you can easily negate multiple columns without having to explicitly alias them all (to avoid a duplicate colnames error).

Notes

I can see that #5669 wanted to codify the naming behaviour as "literal", but I think that's not the way to go as this is an internal implementation detail that the user doesn't see (and therefore can't predict/understand) and that could change (if we wanted to use a dedicated .neg() expression method on the Rust side, change it to expr * -1, etc; the name should stay stable irrespective of the underlying implementation).

Example

Negating a single column:

df = pl.DataFrame({"x": [3, 2, 1]})
df.with_columns(-pl.col("x"))

Before

┌─────┬─────────┐
│ x   ┆ literal │
│ --- ┆ ---     │
│ i64 ┆ i64     │
╞═════╪═════════╡
│ 3   ┆ -3      │
│ 2   ┆ -2      │
│ 1   ┆ -1      │
└─────┴─────────┘

After

┌─────┐
│ x   │
│ --- │
│ i64 │
╞═════╡
│ -3  │
│ -2  │
│ -1  │
└─────┘

Negating multiple columns:

pl.DataFrame(
    {
        "x": [3, 2, 1],
        "y": [6, 7, 8],
    }
).with_columns(-pl.col("x"), -pl.col("y"))

Before

ComputeError: The name: 'literal' passed to `LazyFrame.with_columns` is duplicate

After

┌─────┬─────┐
│ x   ┆ y   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ -3  ┆ -6  │
│ -2  ┆ -7  │
│ -1  ┆ -8  │
└─────┴─────┘

[gab23r]

Isn't it simpler to code it as expr * lit(-1) ?

[alexander-beedie]

Isn't it simpler to code it as expr * lit(-1) ?

That has almost the same behaviour, but not quite; for instance, you can multiply a UInt8 expr by -1, resulting in an Int32, but you'll get an overflow error if you try to negate it; this PR maintains the current behaviour, whereas multiplication would change it by (potentially) modifying the column dtype.

[gab23r]

Ok, thanks for the explanation !