oop - precio - ¿Hay alguna forma de declarar métodos públicos y privados para las clases de referencia S4?

samsung s4

Question

Por adelantado: soy consciente de que R es un lenguaje funcional , así que por favor no muerda ;-)

He tenido grandes experiencias con el uso de un enfoque OOP para muchos de mis programas. Ahora, me pregunto si hay una manera de hacer una distinción entre los métodos públicos y privados cuando se usan las Clases de Referencia S4 en R?

Ejemplo

Definiciones de clase

setRefClass("B",
field=list(
b.1="numeric",
b.2="logical"
),
methods=list(
thisIsPublic=function(...) {
thisIsPublic_ref(.self=.self, ...)
},
thisIsPrivate=function(...) {
thisIsPrivate_ref(.self=.self, ...)
}
)
)
setRefClass("A",
field=list(
a.1="B"
)
)

NOTA

Por lo general, no thisIsPublic_ref definición de método real dentro de la definición de clase, sino que la separo a un método S4 (es decir, thisIsPublic_ref ) por las siguientes razones:

1. De esa manera, la definición de la clase se mantiene claramente ordenada y es más fácil de leer en los casos en que las definiciones de métodos individuales crecen bastante.
2. Le permite cambiar a una ejecución funcional de métodos en cualquier momento. Dado que x una instancia de una determinada clase, puedes llamar a foo_ref(.self=x) lugar de x$foo() .
3. Te permite compilar los métodos a través de compiler::cmpfun() cual creo que no es posible si tienes métodos de clase de referencia "simples".

Es cierto que no tiene sentido hacerlo tan complicado para este ejemplo específico, pero pensé que, sin embargo, ilustraría ese enfoque.

Definiciones de métodos

setGeneric(
name="thisIsPublic_ref",
signature=c(".self"),
def=function(
.self,
...
) {
standardGeneric("thisIsPublic_ref")
}
)
setGeneric(
name="thisIsPrivate_ref",
signature=c(".self"),
def=function(
.self,
...
) {
standardGeneric("thisIsPrivate_ref")
}
)
require(compiler)
setMethod(
f="thisIsPublic_ref",
signature=signature(.self="B"),
definition=cmpfun(function(
.self,
...
){
.self$b.1 * 1000
})
)
setMethod(
f="thisIsPrivate_ref",
signature=signature(.self="B"),
definition=cmpfun(function(
.self,
...
){
.self$b.2
})
)

Instancias

x.b <- new("B", b.1=10, b.2=TRUE)
x.a <- new("A", a.1=x.b, a.2="hello world")

Público vs privado

Las instancias de la clase A (es decir, xa ) deben poder usar los métodos públicos de la clase B :

> x.a$a.1$thisIsPublic()
[1] 10000

Las instancias de la clase A (es decir, xa ) no deben estar autorizadas a utilizar los métodos privados de la clase B Así que me gustaría que esto no funcionara, es decir, dar como resultado un error:

> x.a$a.1$thisIsPrivate()
[1] TRUE

¿Alguna idea de cómo se podría especificar esto?

Lo único que se me ocurrió hasta ahora:

Agregando un argumento de sender a cada método, especifíquelo explícitamente para cada llamada de método y verifique si la class(.self) == class(sender) . Pero eso parece un poco "explícito".

Answer 1

Como las funciones son objetos de primera clase en R, puede incrustar uno dentro del otro de la siguiente manera:

hello <- function() {
print_ <- function() {
return (''hello world'')
}
print_()
}

Sí, es descarado, probablemente no sea la forma más limpia, pero funciona ... Invocar usando ''hello ()''.

Answer 2

La respuesta corta es hacer un paquete. Los sistemas de objetos de R y sus medios de partición de código (espacios de nombres) son más separados que sus equivalentes en lenguajes similares a Java.

Cuando crea un paquete, especifica qué se exporta en un archivo llamado NAMESPACE mediante las directivas export y exportMethods . Puede elegir no exportar métodos y otros objetos R que desee que sean privados para su paquete (para usar la terminología de Java). Consulte la sección Espacios de nombres con clases y métodos de S4 del Manual de escritura de extensiones R

Hacer un paquete es complicado la primera vez que lo haces, pero hay mucha ayuda. Consulte los documentos para package.skeleton y el manual de Writing R Extensions que se encuentra arriba.

Asegúrese de que las clases de referencia son realmente lo que quiere. Las clases regulares de S4 son usualmente la forma más R-ish, para lo que valga. Una gran fuente de información sobre las muchas construcciones OO de R (y sobre el empaquetado también) está en el wiki de los devtools de Hadley Wickham .