Recursion error after upgrade to R_2.11.1 [Sec=Unclassified] [Sec=Unclassified]

On 10/06/2010 06:12 PM, Troy Robertson wrote:

Hi all,

After no replies to my previous message I thought I might show some
code to demonstrate the change and again seek any

explanation for the

error now thrown by my code after upgrading from 2.10.1 to 2.11.1.

Thanks
Troy
--------------------------------------------------------
setClass("PortableObject",
        representation(test1    = "character"),

        prototype(      test1   = ""),
          contains = ".environment"
)

setMethod("initialize", "PortableObject",
    function(.Object, ..., .xData=new.env(parent=emptyenv())) {
                .Object <- callNextMethod(.Object, ...,

.xData=.xData)

                .Object at test1 <- "Foo"
                # Following line works under 2.10.1 but now throws
                # Error: evaluation nested too deeply:

infinite recursion / options(expressions=)?

                #####.Object[["test2"]] <- "Bar"
                # The following does what I want though
                .Object$test3 <- "Baa"

                return(.Object)
        }
)

e <- new("PortableObject")

The explicit example does help -- it's clear what bug you are
encountering. Here's the code in R-2.10

selectMethod("[[<-", ".environment")

Method Definition:

function (x, i, j, ..., value)
{
    call <- sys.call()
    call[[2]] <- x at .Data
    eval.parent(call)
    x
}


and 2.11.1

selectMethod("[[<-", ".environment")

Method Definition:

function (x, i, j, ..., value)
{
    .local <- function (x, i, j, ..., exact = TRUE, value)
    {
        call <- sys.call()
        call[[2]] <- x at .Data
        eval.parent(call)
        x
    }
    .local(x, i, j, ..., value = value)
}

Apparently the 'exact' argument has been added, and because
the method signature differs from the generic, a .local
function is created. That 'sys.call()' originally returned
the environment in which the generic was called, but now it
returns the environment in which .local is defined. And so
eval() keeps evaluating .local(). This I think is a bug.

For what it's worth, if I were interested in minimizing
copying I would set up initialize so that it ended with
callNextMethod(<...>), on the hopes that the method
eventually called would take care not to make too many copies
on slot assignment.

Martin

alterEGo <- function(o = "EPOCObject") {
        o at test1 <- "Boo"

        # Following line works under 2.10.1 but now throws
        # Error: evaluation nested too deeply: infinite

recursion / options(expressions=)?

        ####o[["test2"]] <- "Who"
        # The following does what I want though
        o$test3 <- "Hoo"

        # NOTE: No return
}

alterEGo(e)
e at test1
e$test2
e[["test3"]]
e at .xData[["test3"]]