Returning a list of functions, is this considered an OOP?

Question

I learned this way from the Johns Hopkins MOOC R Programming a long time ago on Coursera. The idea was to return a list of functions that were defined in a father function's scope. For example:

newString <- function(s) {
    l <- nchar(s)
    return(list(
        get = function() return(s),
        len = function() return(l),
        concate = function(cat) {
            s <<- paste0(s, cat)
            l <<- nchar(s)
        },
        find = function(pattern) return(grepl(pattern, s)),
        substitute = function(pattern, sub) {
            s <<- gsub(pattern, sub, s)
            l <<- nchar(s)
        }
    ))
}

This function returns a list of functions/methods which can manipulate the item "s". I can "new" this "object" calling the father function:

my <- newString("hellow")

And using the "methods" with $ just looks like OOP.

my$get()
# [1] "hellow"
my$len()
# [1] 6
my$substitute("w$", "")
my$get()
# [1] "hello"
my$len()
# [1] 5
my$concate(", world")
my$get()
# [1] "hello, world"
my$find("world$")
# [1] TRUE

To print the "object" directly, we can see it is a list of functions. And all these functions located in the same environment 0x103ca6e08, where the item s was also in.

my
# $get
# function () 
#     return(s)
# <bytecode: 0x1099ac1e0>
#     <environment: 0x103ca6e08>
#     
# $len
# function () 
#     return(l)
# <bytecode: 0x109a58058>
#     <environment: 0x103ca6e08>
#     
# $concate
# function (cat) 
# {
#     s <<- paste0(s, cat)
#     l <<- nchar(s)
# }
# <bytecode: 0x1074fd4e8>
#     <environment: 0x103ca6e08>
#     
# $find
# function (pattern) 
#     return(grepl(pattern, s))
# <bytecode: 0x1076c8470>
#     <environment: 0x103ca6e08>
#     
# $substitute
# function (pattern, sub) 
# {
#     s <<- gsub(pattern, sub, s)
#     l <<- nchar(s)
# }
# <bytecode: 0x1077ad270>
#     <environment: 0x103ca6e08>

So is this style of programming (?) considered OOP or OOP-like? What is the difference of this from S3/S4?

---

Thanks to @G.Grothendieck, @r2evans and @Jozef. The demo documentation for scoping in R says "functions can encapsulate state information", because of the scoping rules in R. And the RC system "uses environment", so I think what I did was similar to a primitive RC system.

---

"An object is data with functions. A closure is a function with data." -- John D. Cook

Closures get their name because they enclose the environment of the parent function and can access all its variables.

In http://adv-r.had.co.nz/Functional-programming.html#closures I found the most proper name for this is a closure.

Answer 1

What you are trying to do here reminds me of reference classes or an alternative implementation of the concept by the R6 package - essentially trying to make a OO system similar to other "classic" OOP languages (e.g. Java):

Reference classes:

• https://www.rdocumentation.org/packages/methods/versions/3.5.1/topics/ReferenceClasses

R6

• https://github.com/r-lib/R6/blob/master/README.md

For example, you could define an R6 class like so:

library(R6)

Person <- R6Class("Person",
  public = list(
    name = NULL,
    hair = NULL,
    initialize = function(name = NA, hair = NA) {
      self$name <- name
      self$hair <- hair
      self$greet()
    },
    set_hair = function(val) {
      self$hair <- val
    },
    greet = function() {
      cat(paste0("Hello, my name is ", self$name, ".\n"))
    }
  )
)

And then one can create an instance from that class:

ann <- Person$new("Ann", "black")

For a quick introduction: https://r6.r-lib.org/articles/Introduction.html