Argument matching in partial() doesn't happen for primitive functions

[yutannihilation]

NEWS on version 0.2.3 says:

For instance + is transformed to function(.x, .y) .x + .y. This
results in proper argument matching so that map(1:10, partial(-, .x = 5)) produces list(5 - 1, 5 - 2, ...).

If I understand correctly, using .y instead of .x, map(1:10, partial(-, .y = 5)), will produce list(1 - 5, 2 - 5, ...), right? But it won't:

map_int(1:10, partial(`-`, .y = 5L))
#>  [1]  4  3  2  1  0 -1 -2 -3 -4 -5

Any argument will produce the same result. What does it mean by "proper argument matching" here? Should I use as_mapper() explicitly by myself?

map_int(1:10, partial(`-`, any_inproper_argument = 5L))
#>  [1]  4  3  2  1  0 -1 -2 -3 -4 -5

[egnha]

Primitive functions, like -, are “special,” in that they don't generally have the match-by-name semantics for arguments that closures do. This is why the any_improper_argument case also gives the same result. Additionally, partial() will put the set values in front of the others, by default:

partial(`-`, .y = 5L)
#> function (...) 
#> 5L - ...

So you have to reverse that:

partial(`-`, .y = 5L, .first = FALSE)
#> function (...) 
#> ... - 5L

[yutannihilation]

Thanks for the comment. Yes, I know it and the work around of using .first. But, NEWS says we can match by using as_mapper() (and I thought it is automatically done in partial()).

map_int(1:10, partial(as_mapper(`-`), .y = 5L))

[egnha]

@yutannihilation Then you are right that the documentation is not completely accurate, and maybe even a bit misleading.

[yutannihilation]

If this is merely a documentation problem, I'm happy to close this issue :)

[lionel-]

It seems we forgot to call as_closure() in partial().

[yutannihilation]

@lionel-

Are you going to fix this? I'm getting a feeling that this is rather ok with the current behaviour because automatically converting primitives with as_closure() is a bit tricky.

As the prototype says the arguments are e1 and e2, I naturally assumed the argument to pass to partial() is e1 or e2 when I attempted to use partial() with primitive functions at the first time. I mean, those who naively use partial() with primitive functions will get confused no matter whether as_quosure() is automatically applied or not.

`-`
#> function (e1, e2)  .Primitive("-")

I guess adding some notes about primitive functions on the documentation of partial() is enough.

[lionel-]

Note that those argument names e1 and e2 are only indicative and are never used by the primitive function.

I thought it was a good idea to use .x and .y so you could do stuff like map(1:3, -, .x = 10), but it of course doesn't work because .x matches the map() argument :/.

[yutannihilation]

Note that those argument names e1 and e2 are only indicative and are never used by the primitive function.

This is what I didn't know until attempting to match e2... 😇

.x matches the map() argument :/.

Oh, sad...

[lionel-]

Binary operators wrapped with as_closure() now support both purrr-style and base-style arguments btw (you need dev rlang though).