R language Functions within lists - r

Question

G'Day, I am a newbie at R and I have GOOGLED and read books and had lots of play, but I can't seem to figure out if what I am doing is implemented. It compiles (no interpreter spit) and can be called (again no spit), it just doesn't seem to want to do anything.
OK. SYNOPSIS.
I read that lists in R are the OBJECTS of other languages. So just for a Saturday and Sunday play I have been trying to get this to work.
GLOBAL <- list( counter = 1,
locked = FALSE,
important_value = 42,
copy_of_important_value = 42,
lock = function() { GLOBAL$locked = TRUE },
unlock = function() { GLOBAL$locked = FALSE },
is_locked = function() { return(GLOBAL$locked )},
visit = function() { GLOBAL$counter <- GLOBAL$counter + 1 })
> GLOBAL$locked
[1] FALSE
>
This works...
> GLOBAL$locked <- TRUE
> GLOBAL$locked
[1] TRUE
>
This does not
> GLOBAL$unlock()
> GLOBAL$locked
[1] TRUE
>
Has R got a $this or $self construct? None of this generates any errors. Just doesn't seem to want to do anything! (functions that is). I suppose I could set up a function as a routing access table, but I thought the encapsulation would be nifty.
Second question. It has been mentioned to me several times that R MUST keep all data in memory, and that is a limitation. Does that include swp on *NIX systems? I mean, if you had a humungus matrix could you just add some swap to make it fit?
Sorry for dumb newbie questions

Answer 1

This can be done using proto objects:
library(proto) # home page at http://r-proto.googlecode.com
GLOBAL <- proto( counter = 1,
locked = FALSE,
important_value = 42,
copy_of_important_value = 42,
lock = function(.) { .$locked = TRUE },
unlock = function(.) { .$locked = FALSE },
is_locked = function(.) { return(.$locked )},
visit = function(.) { .$counter <- .$counter + 1 })
GLOBAL$locked <- TRUE
GLOBAL$unlock()
GLOBAL$locked
## FALSE

Answer 2

The S3 way of doing things.
GLOBAL <- list(counter=1, locked=FALSE,
important_value=42, copy_of_important_value=42)
class(GLOBAL) <- "foo"
lock <- function(x, ...) UseMethod("lock")
lock.foo <- function(x)
{
x$locked <- TRUE
x
}
unlock <- function(x, ...) UseMethod("unlock")
unlock.foo <- function(x)
{
x$locked <- FALSE
x
}
is_locked <- function(x) x$locked
visit <- function(x)
{
x$counter <- x$counter + 1
x
}
GLOBAL <- lock(GLOBAL) # locked is now TRUE
GLOBAL <- unlock(GLOBAL) # locked is now FALSE

Answer 3

There's also the enclosure method
getGlobal <- function() {
counter <- 1
locked <- FALSE
important_value <- 42
list(
is_locked = function() locked,
lock = function() locked<<-TRUE,
unlock = function() locked<<-FALSE,
visit = function() {counter <<- counter + 1 }
)
}
And then you would use
GLOBAL <- getGlobal()
GLOBAL$is_locked()
# [1] FALSE
GLOBAL$lock()
GLOBAL$is_locked()
# [1] TRUE
So the state is stored in the enclosure and getGlobal returns a list of functions you can use to access those variables not otherwise exposed.

Answer 4

Nothing happened because
R doesn't have any variables to go get because they way you have it, = does not mean assignment has occurred inside the list(). So the only object in the global environment is GLOBAL. The way you're using = right now is assigning the list names to the left-hand side, and they are subsequently accessed with the $ operator.
Your functions are not returning a value as they're written. GLOBAL$locked() will not return a value if GLOBAL$locked <- FALSE is all you have inside the body of the function that calls it. So I wrap it in parentheses, and is returns our desire values.
So we just need to assign locked to the global environment first, then <<- will reassign it.
I shortened your list a bit. Here's a look:
> GLOBAL <- list(locked = assign("locked", FALSE, parent.frame()),
lock = function() { (GLOBAL$locked <<- TRUE) },
unlock = function() { (GLOBAL$locked <<- 'HELLO') },
is_locked = function() { return(NULL) })
> GLOBAL$locked
[1] FALSE
> GLOBAL$lock()
[1] TRUE
> GLOBAL$unlock()
[1] "HELLO"
> GLOBAL$is_locked()
NULL
Yes, a list has its own environment, separate from the global environment. An example of this is
> l <- list(x = 5, y = 10)
> within(l, {
f <- function(x) 2 * x
})
$x
[1] 5
$y
[1] 10
$f
function (x)
2 * x
<environment: 0xb041278>
but we are currently in the global environment
> environment()
<environment: R_GlobalEnv>
It's funny you should ask this question because I just asked a question about the same thing yesterday. MrFlick provided a very good explanation on that question.