תבנית Iterator

חלק מהיחידה תכנות מונחה עצמים במסלול ה-R של Coddy. שיעור 49 מתוך 57.

איטרטור מספק את הפריטים של אוסף בזה אחר זה, כך שהקוד שמשתמש בהם לא צריך לדעת כיצד האוסף מאוחסן. סגירה שומרת את המיקום; has_next() ו־next_value() הם כל הממשק:

make_iterator <- function(x) {
  i <- 0
  list(
    has_next = function() i < length(x),
    next_value = function() {
      i <<- i + 1
      x[[i]]
    }
  )
}
it <- make_iterator(c("a", "b", "c"))
while (it$has_next()) cat(it$next_value(), "")

פלט:

a b c

מחולל הוא איטרטור שמחשב כל ערך כשמבקשים אותו, כך שאין צורך שהרצף יהיה קיים בזיכרון. הוא אפילו יכול להיות אינסופי:

make_fib <- function() {
  a <- 0
  b <- 1
  list(has_next = function() TRUE,
       next_value = function() {
         value <- a
         nxt <- a + b
         a <<- b
         b <<- nxt
         value
       })
}
fib <- make_fib()
for (i in 1:10) cat(fib$next_value(), "")

פלט:

0 1 1 2 3 5 8 13 21 34

ה־iterator מסתיר את הפריסה. תוצאות המאוחסנות בדפים, שחלקם ריקים, יוצאות כרצף שטוח אחד:

make_paged <- function(pages) {
  p <- 1
  i <- 0
  skip_empty <- function() while (p <= length(pages) && i >= length(pages[[p]])) { p <<- p + 1; i <<- 0 }
  list(
    has_next = function() { skip_empty(); p <= length(pages) },
    next_value = function() { skip_empty(); i <<- i + 1; pages[[p]][i] }
  )
}
it <- make_paged(list(c("a", "b"), character(0), c("c")))
while (it$has_next()) cat(it$next_value(), "")

פלט:

a b c

פונקציות עזר שנכתבו עבור הממשק פועלות עם כל איטרטור. take(it, n) שולפת עד n ערכים, מווקטור, מגנרטור או מכל דבר אחר שיש בו has_next() ו-next_value():

make_iterator <- function(x) {
  i <- 0
  list(has_next = function() i < length(x), next_value = function() { i <<- i + 1; x[[i]] })
}
take <- function(it, n) {
  out <- c()
  while (length(out) < n && it$has_next()) out <- c(out, it$next_value())
  out
}
it <- make_iterator(1:5)
print(take(it, 2))
print(take(it, 10))

פלט:

[1] 1 2
[1] 3 4 5

אתגר

קל

השלימו את Iterator.R:

make_iterator(x): איטרטור על איברי וקטור, עם has_next() ו-next_value();
make_range(from, to, by): מחולל של from, from + by, ... עד וכולל to, כשהערכים מחושבים אחד בכל פעם;
take(it, n): עד n הערכים הבאים של כל איטרטור.

הקוד שסופק קורא שורות range 1 10 3 take 2 5 (from, to, by, ואז הגדלים של כל קריאה ל-take) או list a,b,c take 2 2, ומדפיס את הערך שמחזירה כל קריאה ל-take().

הקוד שלך ייכתב ב-Iterator.R. הקובץ main.R מכיל את קוד הקלט/פלט שסופק ואי אפשר לערוך אותו.

נסו בעצמכם

source("Iterator.R")

# קוד הקלט/פלט שסופק: יש להשאיר אותו כפי שהוא
input <- suppressWarnings(readLines(file("stdin")))
for (line in input) {
  p <- strsplit(line, " ")[[1]]
  it <- if (p[1] == "range") make_range(as.numeric(p[2]), as.numeric(p[3]), as.numeric(p[4])) else make_iterator(strsplit(p[2], ",")[[1]])
  k <- if (p[1] == "range") 5 else 3
  for (n in as.numeric(p[-(1:k)])) {
    got <- take(it, n)
    cat("take ", n, ": ", if (length(got) == 0) "(nothing)" else paste(got, collapse = " "), "\n", sep = "")
  }
}