R devel - Nov 2019 - BUG?: A copy of base::`+` (primitive) is not a clone but a "pointer"

$ R --vanilla
R version 3.6.1 (2019-07-05) -- "Action of the Toes"
Copyright (C) 2019 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
...
> str(base::`+`)
function (e1, e2)
> plus <- structure(base::`+`, class = "plus")
> str(plus)
function (e1, e2)
 - attr(*, "class")= chr "plus"

## Hmm ...
> str(base::`+`)
function (e1, e2)
 - attr(*, "class")= chr "plus"
> class(base::`+`) <- NULL
> str(base::`+`)
function (e1, e2)

## Hmm ...
> str(plus)
function (e1, e2)

Even without assigning to `plus`, you get this behavior:

$ R --vanilla
> structure(base::`+`, class = "plus")
function (e1, e2)  .Primitive("+")
attr(,"class")
[1] "plus"

# Hmm...
> str(base::`+`)
function (e1, e2)
 - attr(*, "class")= chr "plus"

Looks to be the case for common (all?) .Primitive functions.  Is this
expected? Should I report this one to BugZilla?

/Henrik

>>>>> Henrik Bengtsson 
>>>>>     on Sun, 17 Nov 2019 14:31:07 -0800 writes:
    > $ R --vanilla R version 3.6.1 (2019-07-05) -- "Action of
    > the Toes" Copyright (C) 2019 The R Foundation for
    > Statistical Computing Platform: x86_64-pc-linux-gnu
    > (64-bit) ...

    >> str(base::`+`)
    > function (e1, e2)

    >> plus <- structure(base::`+`, class = "plus") str(plus)
    > function (e1, e2) - attr(*, "class")= chr "plus"

    > ## Hmm ...
    >> str(base::`+`)
    > function (e1, e2) - attr(*, "class")= chr "plus"

    >> class(base::`+`) <- NULL str(base::`+`)
    > function (e1, e2)

    > ## Hmm ...
    >> str(plus)
    > function (e1, e2)

    > Even without assigning to `plus`, you get this behavior:

    > $ R --vanilla
    >> structure(base::`+`, class = "plus")
    > function (e1, e2) .Primitive("+") attr(,"class")
[1]
    > "plus"

    > # Hmm...
    >> str(base::`+`)
    > function (e1, e2) - attr(*, "class")= chr "plus"

    > Looks to be the case for common (all?) .Primitive
    > functions.

No need for 'base::' (who would be crazy enough to redefine `+`?)
nor str() actually:

attr(`+`, "class") <- NULL  # (reset)
`+`
structure(`+`, class = "plus")
`+`

is clearly convincing and minimal
> attr(`+`, "class") <- NULL
> `+`
function (e1, e2)  .Primitive("+")
> structure(`+`, class = "plus")
function (e1, e2)  .Primitive("+")
attr(,"class")
[1] "plus"
> `+`
function (e1, e2)  .Primitive("+")
attr(,"class")
[1] "plus"
> 
---------------------------------------------------------

    > Is this expected? 

no.  (at least not by 99.999% of R users)


    > Should I report this one to Bugzilla?
yes, please.

    > /Henrik

On 11/18/19 9:18 AM, Martin Maechler wrote:
>>>>>> Henrik Bengtsson
>>>>>>      on Sun, 17 Nov 2019 14:31:07 -0800 writes:
>      > $ R --vanilla R version 3.6.1 (2019-07-05) -- "Action of
>      > the Toes" Copyright (C) 2019 The R Foundation for
>      > Statistical Computing Platform: x86_64-pc-linux-gnu
>      > (64-bit) ...
>
>      >> str(base::`+`)
>      > function (e1, e2)
>
>      >> plus <- structure(base::`+`, class = "plus")
str(plus)
>      > function (e1, e2) - attr(*, "class")= chr
"plus"
>
>      > ## Hmm ...
>      >> str(base::`+`)
>      > function (e1, e2) - attr(*, "class")= chr
"plus"
>
>      >> class(base::`+`) <- NULL str(base::`+`)
>      > function (e1, e2)
>
>      > ## Hmm ...
>      >> str(plus)
>      > function (e1, e2)
>
>      > Even without assigning to `plus`, you get this behavior:
>
>      > $ R --vanilla
>      >> structure(base::`+`, class = "plus")
>      > function (e1, e2) .Primitive("+")
attr(,"class") [1]
>      > "plus"
>
>      > # Hmm...
>      >> str(base::`+`)
>      > function (e1, e2) - attr(*, "class")= chr
"plus"
>
>      > Looks to be the case for common (all?) .Primitive
>      > functions.
>
> No need for 'base::' (who would be crazy enough to redefine `+`?)
> nor str() actually:
>
> attr(`+`, "class") <- NULL  # (reset)
> `+`
> structure(`+`, class = "plus")
> `+`
>
> is clearly convincing and minimal
>
>> attr(`+`, "class") <- NULL
>> `+`
> function (e1, e2)  .Primitive("+")
>> structure(`+`, class = "plus")
> function (e1, e2)  .Primitive("+")
> attr(,"class")
> [1] "plus"
>> `+`
> function (e1, e2)  .Primitive("+")
> attr(,"class")
> [1] "plus"
> ---------------------------------------------------------
>
>      > Is this expected?
>
> no.  (at least not by 99.999% of R users)
>
>
>      > Should I report this one to Bugzilla?
> yes, please.
>
>      > /Henrik
A shorter example is

 > p1 <- .Primitive('+') ; p2 <- p1 ; attr(p1,
"myattr") <- 1 ; p2
function (e1, e2)? .Primitive("+")
attr(,"myattr")
[1] 1

Builtins have referential semantics in R (like e.g. environments, but 
also some other types).

Tomas

>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel