Enum-wie Argumente in R

Wie wäre es mit einer Funktion, die definiert, die enum-durch Rücksendung list(a= "a", ...)? Sie können dann entweder weisen Sie den zurückgegebenen Vektor einer Variablen zu, und verwenden Sie es im Kontext, oder verwenden Sie die Funktion direkt. Entweder ein name oder eine integer-Referenz funktioniert wie ein index, obwohl Sie die unlist version des index-lookup [[, sonst bekommt man eine Liste mit einem element.

colorEnum <- function() {
    list(BLUE = "BLUE", RED = "RED", BLACK = "BLACK")
}

colorEnum()$BLUE
#> [1] "BLUE"
colorEnum()[[1]]
#> [1] "BLUE"
colorEnum()[1]
#> $BLUE
#> [1] "BLUE"

col <- colorEnum()
col$BLUE
#> [1] "BLUE"
col[[1]]
#> [1] "BLUE"
col$BAD_COLOR
#> NULL
col[[5]]
#> Error in col[[5]] : subscript out of bounds

Können Sie die Liste der Namen für die Verwendung in einem match, d.h. Ihre Funktion parameter könnte

EnumTest = function( enum = names(colorEnum()) { ...

Kann man eigentlich abkürzen, aber es muss eindeutig sein. (Wenn Sie mit RStudio, da col ist eine Liste, es schlägt Ergänzungen!)

col$BLA
#> [1] "BLACK"
col$BL
#> NULL

Wenn Sie wollen mehr anspruchsvolle enum Handhabung, die man zuordnen könnte S3-Klassen, um die Sache zurückgegeben, indem Sie Ihre enum-Konstruktor-Funktion und schreiben Sie eine kleine Sammlung von Funktionen zum Versand auf die Klasse "enum" und ermöglichen groß-und Kleinschreibung Indizierung. Sie könnten auch spezielle Funktionen zum arbeiten mit einer bestimmten Klasse, z.B. "colorEnum"; ich habe dies nicht getan hier. Vererbung bedeutet, dass die Liste mit access-Methoden, die alle noch funktionieren.

colorEnum2 <- function() {
    structure(
        list(BLUE = "BLUE", RED = "RED", BLACK = "BLACK"),
        class= c("colorEnum2", "enum", "list")
    )
}

# Note, changed example to allow multiple returned values.
`[.enum` <- function(x, i) {
    if ( is.character( i ))
        i <- toupper(i)
    class(x) <- "list"
    names(as.list(x)[i])
}

`[[.enum` <- function(x, i, exact= FALSE) {
    if ( is.character( i ))
        i <- toupper(i)
    class(x) <- "list"
    as.list(x)[[i, exact=exact]]
}

`$.enum` <- function(x, name) {
    x[[name]]
}

col <- colorEnum2()
# All these return [1] "RED"
col$red
col$r
col[["red"]]
col[["r"]]
col["red"]

col[c("red", "BLUE")]
#> [1] "RED" "BLUE"

col["r"]
[1] NA   # R does not matches partial strings with "["

Diese überschreiben Sie die eingebaute [, [[ und $ Funktionen, wenn das Ding indiziert ist Klasse "enum", für jedes "enum" eingestuft Objekte. Wenn Sie einen weiteren benötigen, brauchen Sie nur, um Sie zu definieren.

 directionEnum <- function() {
    structure(
        list(LEFT = "LEFT", RIGHT = "RIGHT"),
        class= c("directionEnum", "enum", "list")
    )
}

directionEnum()$l
#> [1] "LEFT"

Wenn Sie mehrere enum-Objekte, fügen Sie eine factory-Funktion enum nimmt einen Vektor von Zeichenketten und einen Namen und gibt eine enum Objekt. Die meisten dieser ist nur zur überprüfung.

enum <- function(enums, name= NULL) {
    if (length(enums) < 1)
        stop ("Enums may not be empty." )
    enums <- toupper(as.character(enums))
    uniqueEnums <- unique(enums)
    if ( ! identical( enums, uniqueEnums ))
        stop ("Enums must be unique (ignoring case)." )
    validNames <- make.names(enums)
    if ( ! identical( enums, validNames ))
       stop( "Enums must be valid R identifiers." )

    enumClass <- c(name, "enum", "list")
    obj <- as.list(enums)
    names(obj) <- enums
    structure( obj, class= enumClass)
}

col <- enum(c("BLUE", "red", "Black"), name = "TheColors")
col$R
#> [1] "RED"
class(col)
#> [1] "TheColors" "enum"      "list"

side <- enum(c("left", "right"))
side$L
#> [1] "LEFT"
class(side)
#> [1] "enum" "list"

Aber das ist jetzt angefangen zu schauen, wie ein Paket...

Ich nur konfrontiert, die genau dieses problem und konnte nur finden das SO Frage. Die Objekteigenschaften Paket Erwähnung von Paul scheint aufgegeben (es giebt mehrere Warnungen) und hat viel Aufwand für so eine einfache (im Prinzip) problem. Ich kam mit der folgenden leichten Lösung (hängt nur von der stringi - Paket), die reproduziert das Gefühl von Enumerationen in C-Sprachen. Vielleicht hilft dies ja jemanden.

EnumTest <- function(colorEnum = ColorEnum$BLUE) {
  enumArg <- as.character(match.call()[2])
  match.arg(enumArg, stringi::stri_c("ColorEnum$", names(ColorEnum)))
  sprintf("%s: %i",enumArg,colorEnum)
}

ColorEnum <- list(BLUE = 0L, RED = 1L, BLACK = 2L)

Update 07/21/2017: ich habe ein Paket für Aufzählungen in R:

https://github.com/aryoda/R_enumerations

Wenn Sie verwenden möchten, die Sie selbst definiert enum-alike-Datentypen die als Argumente der R-Funktionen, dass die Unterstützung

• automatische übersetzung von enum-Element-Namen in die entsprechenden integer-Werte
• code auto-Vervollständigung (e. g. in RStudio)
• übersichtliche Dokumentation in die Funktion Signatur, welche Werte erlaubt sind als aktuelle Parameter der Funktion
• einfache Validierung der tatsächlichen Funktion parameter gegen die erlaubten (integer) enum-Element Werte

definieren Sie Ihre eigenen match.enum.arg - Funktion, e. g.:

match.enum.arg <- function(arg, choices) {
  if (missing(choices)) {
    formal.args <- formals(sys.function(sys.parent()))
    choices <- eval(formal.args[[as.character(substitute(arg))]])
  }

  if(identical(arg, choices))
    arg <- choices[[1]][1]    # choose the first value of the first list item

  allowed.values <- sapply(choices,function(item) {item[1]})   # extract the integer values of the enum items

  if(!is.element(arg, allowed.values))
    stop(paste("'arg' must be one of the values in the 'choices' list:", paste(allowed.values, collapse = ", ")))

  return(arg)
}

Verwendung:

Können Sie dann definieren Sie und verwenden Sie Ihre eigenen enums wie diese:

ColorEnum <- list(BLUE = 1L, RED = 2L, BLACK = 3L)

color2code = function(enum = ColorEnum) { 
  i <- match.enum.arg(enum)
  return(i)
}

Beispiel-Aufrufe:

> color2code(ColorEnum$RED) # use a value from the enum (with auto completion support)
[1] 2
> color2code()              # takes the first color of the ColorEnum
[1] 1
> color2code(3)             # an integer enum value (dirty, just for demonstration)
[1] 3
> color2code(4)             # an invalid number
Error in match.enum.arg(enum) : 
  'arg' must be one of the values in the 'choices' list: 1, 2, 3