select/transform: old_column => fun => new_column_name syntax

[cleytonfar]

Weird output when using select(), select!(), transform() and transform!() with anonymous function.
For example:

using DataFrames
df = DataFrame(a = 1:3, b = 4:6)
select(df, :a => x->x*2)

the output will be

3×1 DataFrame
│ Row │ a_function │
│     │ Int64      │
├─────┼────────────┤
│ 1   │ 2          │
│ 2   │ 4          │
│ 3   │ 6          │

However, if I try to give a new name to the transformed column:

select(df, :a => x->x*2 =>:d)

the output will be:

│ Row │ a_function    │
│     │ Pair…         │
├─────┼───────────────┤
│ 1   │ [2, 4, 6]=>:d │
│ 2   │ [2, 4, 6]=>:d │
│ 3   │ [2, 4, 6]=>:d │

One fix is to wrap the anonymous function using ByRow() :

select(df, :a => ByRow(x->x*2) => :d)

3×1 DataFrame
│ Row │ d     │
│     │ Int64 │
├─────┼───────┤
│ 1   │ 2     │
│ 2   │ 4     │
│ 3   │ 6     │

or define your own function:

function myfun(x)
    x*2
end

select(df, :a => myfun => :d)

3×1 DataFrame
│ Row │ d     │
│     │ Int64 │
├─────┼───────┤
│ 1   │ 2     │
│ 2   │ 4     │
│ 3   │ 6     │

I am not sure if this behavior is intended or some small issue. I think the code would be clearer if we did not need to wrap the anonymous function with ByRow or define our own functions to pass to select/transform.

[bkamins]

I think the code would be clearer if we did not need to wrap the anonymous function with ByRow

ByRow is not needed, you just need to wrap the function in ( and ) due to precedence rules in Julia:

select(df, :a => (x->x*2) =>:d)

When debugging, it is usually simplest just to paste the expression in question in REPL. In this case you see:

julia> :a => x->x*2 =>:d
:a => var"#3#4"()

julia> :a => (x->x*2) =>:d
:a => (var"#5#6"() => :d)

which shows you the root-cause of the problem.