［翻訳］R6 vignette: R6クラス入門

この文書は，Winston Chang によるRパッケージ [`R6`](https://cran.r-project.org/package=R6) (version 2.2.0) のビネット ["Introduction to R6 classes"](https://cran.r-project.org/package=R6/vignettes/Introduction.html) の日本語訳です．

License: [MIT](https://opensource.org/licenses/MIT)

**関連文書**

- [R6クラス入門](http://qiita.com/nakamichi/items/d724468e0f716d7a174c)
- [移植可能R6クラスと移植不可R6クラス](http://qiita.com/nakamichi/items/b1240935894c2ca72c98)
- [R6オブジェクトのメソッドのデバッグ](http://qiita.com/nakamichi/items/97551ebc6bdfe1119cba)
- [R6と参照クラスの性能テスト](http://qiita.com/nakamichi/items/1841e7450a5621fa7142)

----



<!-- The R6 package provides a type of class which is similar to R's standard reference classes, but it is more efficient and doesn't depend on S4 classes and the methods package. -->

R6パッケージは，R標準の参照クラスに類似した種類のクラスを提供します．ただしR6はより効率的であり，S4クラスや`methods`パッケージに依存しません．

<!-- ## R6 classes -->

## R6クラス

<!-- R6 classes are similar to R's standard reference classes, but are lighter weight, and avoid some issues that come along with using S4 classes (R's reference classes are based on S4). For more information about speed and memory footprint, see the Performance vignette. -->

R6クラスはR標準の参照クラスに似ていますが，より軽量であり，S4クラスの使用に伴う問題を回避しています（Rの参照クラスはS4に基づいています）．速度とメモリ負荷に関する詳しい情報については，「性能」のビネットを参照してください．

<!-- Unlike many objects in R, instances (objects) of R6 classes have reference semantics. R6 classes also support: -->

Rの多くのオブジェクトとは異なり，R6クラスのインスタンス（オブジェクト）は参照セマンティクスです．また，R6クラスは以下の機能をサポートしています．

<!-- * public and private methods -->
<!-- * active bindings -->
<!-- * inheritance (superclasses) which works across packages -->

* パブリックメソッドとプライベートメソッド
* 活性束縛（active bindings）
* パッケージをまたいで動作する継承（スーパークラス）

<!-- Why the name R6? When R's reference classes were introduced, some users, following the names of R's existing class systems S3 and S4, called the new class system R5 in jest. Although reference classes are not actually called R5, the name of this package and its classes takes inspiration from that name. -->

なぜパッケージ名がR6なのでしょうか？Rの参照クラスが導入された際に，Rの既存のクラスシステム名であるS3とS4に従って，新しいクラスシステムを冗談でR5と呼ぶユーザがいました．参照クラスが実際にR5と名付けられることはありませんでしたが，このパッケージとクラスの名前はそこからインスピレーションを得ています．

<!-- The name R5 was also a code-name used for a different object system started by Simon Urbanek, meant to solve some issues with S4 relating to syntax and performance. However, the R5 branch was shelved after a little development, and it was never released. -->

また，R5はSimon UrbanekがS4の文法と性能に関する問題を解決するために始めた，別のオブジェクトシステムのコードネームでもありました．しかしR5のブランチは少し開発が行われた後に中止され，リリースされることはありませんでした．

<!-- ### Basics -->

### 基本

<!-- Here's how to create a simple R6 class. The `public` argument is a list of items, which can be functions and fields (non-functions). Functions will be used as methods. -->

単純なR6クラスを作成する方法を示します．`public`引数はリストであり，リストの要素にできるのは関数かフィールド（関数以外）です．関数はメソッドとして使われます．


```r
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"))
    }
  )
)
```

<!-- To instantiate an object of this class, use `$new()`: -->

このクラスのオブジェクトをインスタンス化するには`$new()`を使います．


```r
ann <- Person$new("Ann", "black")
#> Hello, my name is Ann.
ann
#> <Person>
#>   Public:
#>     clone: function (deep = FALSE) 
#>     greet: function () 
#>     hair: black
#>     initialize: function (name = NA, hair = NA) 
#>     name: Ann
#>     set_hair: function (val)
```

<!-- The `$new()` method creates the object and calls the `initialize()` method, if it exists. -->

`$new()`メソッドはオブジェクトを作成し，`initialize()`メソッドが存在していれば呼び出します．

<!-- Inside methods of the class, `self` refers to the object. Public members of the object (all you've seen so far) are accessed with `self$x`, and assignment is done with `self$x <- y`. Note that by default, `self` is required to access members, although for non-portable classes which we'll see later, it is optional. -->

クラスのメソッド内において，`self`はそのクラスのオブジェクト自身のことを指します．オブジェクトのパブリックメンバ（ここまで見てきたものはすべてそうです）には`self$x`でアクセスし，代入は`self$x <- y`で行います．後で見るように，移植不可（non-portable）クラスでは`self`を省略できますが，デフォルトではメンバにアクセスするのに`self`が必要なことに注意してください．

<!-- Once the object is instantiated, you can access values and methods with `$`: -->

オブジェクトがインスタンス化されたら，値やメソッドには`$`でアクセスできます．


```r
ann$hair
#> [1] "black"
ann$greet()
#> Hello, my name is Ann.
ann$set_hair("red")
ann$hair
#> [1] "red"
```

<!-- Implementation note: The external face of an R6 object is basically an environment with the public members in it. This is also known as the *public environment*. An R6 object's methods have a separate *enclosing environment* which, roughly speaking, is the environment they "run in". This is where `self` binding is found, and it is simply a reference back to public environment. -->

実装についてのノート：外側から見ると，基本的にはR6オブジェクトというのはパブリックメンバを含む環境です．これはまた，**パブリック環境**として知られているものです．R6オブジェクトのメソッドはこれとは別に**エンクロージング環境**を持ちます．おおまかに言うと，エンクロージング環境とはその中でメソッドが実行される環境のことです．エンクロージング環境では`self`が束縛されている値が見つかりますが，これはパブリック環境への単なる参照です．

<!-- ### Private members -->

### プライベートメンバ

<!-- In the previous example, all the members were public. It's also possible to add private members: -->

前の例ではすべてのメンバがパブリックでしたが，プライベートメンバを加えることもできます．


```r
Queue <- R6Class("Queue",
  public = list(
    initialize = function(...) {
      for (item in list(...)) {
        self$add(item)
      }
    },
    add = function(x) {
      private$queue <- c(private$queue, list(x))
      invisible(self)
    },
    remove = function() {
      if (private$length() == 0) return(NULL)
      # private$queue を使って明示的にアクセスできる
      head <- private$queue[[1]]
      private$queue <- private$queue[-1]
      head
    }
  ),
  private = list(
    queue = list(),
    length = function() base::length(private$queue)
  )
)

q <- Queue$new(5, 6, "foo")
```

<!-- Whereas public members are accessed with `self`, like `self$add()`, private members are accessed with `private`, like `private$queue`. -->

パブリックメンバには`self`を使って`self$add()`のようにアクセスしますが，プライベートメンバには`private`を使って`private$queue`のようにアクセスします．

<!-- The public members can be accessed as usual: -->

パブリックメンバには通常通りアクセスできます．


```r
# 項目の追加と削除
q$add("something")
q$add("another thing")
q$add(17)
q$remove()
#> [1] 5
q$remove()
#> [1] 6
```

<!-- However, private members can't be accessed directly: -->

しかし，プライベートメンバには直接アクセスすることはできません．


```r
q$queue
#> NULL
q$length()
#> Error: attempt to apply non-function
```

<!-- A useful design pattern is for methods to return `self` (invisibly) when possible, because it makes them chainable. For example, the `add()` method returns `self` so you can chain them together: -->
可能であればメソッドが`self`を（不可視的に）返すようにするのは有用なデザインパターンです．というのもメソッドの連鎖ができるようになるからです．たとえば，`add()`メソッドは`self`を返すので，連鎖させることができます．


```r
q$add(10)$add(11)$add(12)
```

<!-- On the other hand, `remove()` returns the value removed, so it's not chainable: -->

一方，`remove()`は削除された値を返すので，連鎖させることはできません．


```r
q$remove()
#> [1] "foo"
q$remove()
#> [1] "something"
q$remove()
#> [1] "another thing"
q$remove()
#> [1] 17
```


<!-- ### Active bindings -->

### 活性束縛（active binding）

<!-- Active bindings look like fields, but each time they are accessed, they call a function. They are always publicly visible. -->

活性束縛は見かけはフィールドのようですが，アクセスされる度に関数を呼び出します．活性束縛は常にパブリックです．


```r
Numbers <- R6Class("Numbers",
  public = list(
    x = 100
  ),
  active = list(
    x2 = function(value) {
      if (missing(value)) return(self$x * 2)
      else self$x <- value/2
    },
    rand = function() rnorm(1)
  )
)

n <- Numbers$new()
n$x
#> [1] 100
```

<!-- When an active binding is accessed as if reading a value, it calls the function with `value` as a missing argument: -->

活性束縛に値を読むかのようにしてアクセスすると，対応する関数が`value`引数を欠損として呼び出されます．


```r
n$x2
#> [1] 200
```

<!-- When it's accessed as if assigning a value, it uses the assignment value as the `value` argument: -->
値を代入するかのようにしてアクセスすると，代入値が`value`引数として使われます．


```r
n$x2 <- 1000
n$x
#> [1] 500
```

<!-- If the function takes no arguments, it's not possible to use it with `<-`: -->
活性束縛した関数が引数を取らない場合，活性束縛を`<-`と一緒に使うことはできません．


```r
n$rand
#> [1] 0.2648
n$rand
#> [1] 2.171
n$rand <- 3
#> Error: unused argument (quote(3))
```

<!-- Implementation note: Active bindings are bound in the public environment. The enclosing environment for these functions is also the public environment. -->

実装についてのノート：活性束縛はパブリック環境に束縛されます．活性束縛の関数のエンクロージング環境もパブリック環境です．

<!-- ### Inheritance -->

### 継承

<!-- One R6 class can inherit from another. In other words, you can have super- and sub-classes. -->

ひとつのR6クラスは別のR6クラスを継承することができます．言い換えると，スーパークラスとサブクラスを作ることができます．

<!-- Subclasses can have additional methods, and they can also have methods that override the superclass methods. In this example of a queue that retains its history, we'll add a `show()` method and override the `remove()` method: -->

サブクラスは追加のメソッドを持つことができ，スーパークラスのメソッドをオーバーライドするメソッドを持つこともできます．以下の履歴を保持するキューの例では，`show()`メソッドを追加して`remove()`メソッドをオーバーライドします．

<!-- # Note that this isn't very efficient - it's just for illustrating inheritance. -->

```r
# このキューは非効率なので注意．単に継承を例示するためのものです．
HistoryQueue <- R6Class("HistoryQueue",
  inherit = Queue,
  public = list(
    show = function() {
      cat("Next item is at index", private$head_idx + 1, "\n")
      for (i in seq_along(private$queue)) {
        cat(i, ": ", private$queue[[i]], "\n", sep = "")
      }
    },
    remove = function() {
      if (private$length() - private$head_idx == 0) return(NULL)
      private$head_idx <<- private$head_idx + 1
      private$queue[[private$head_idx]]
    }
  ),
  private = list(
    head_idx = 0
  )
)

hq <- HistoryQueue$new(5, 6, "foo")
hq$show()
#> Next item is at index 1 
#> 1: 5
#> 2: 6
#> 3: foo
hq$remove()
#> [1] 5
hq$show()
#> Next item is at index 2 
#> 1: 5
#> 2: 6
#> 3: foo
hq$remove()
#> [1] 6
```

<!-- Superclass methods can be called with `super$xx()`. The `CountingQueue` (example below) keeps a count of the total number of objects that have ever been added to the queue. It does this by overriding the `add()` method -- it increments a counter and then calls the superclass's `add()` method, with `super$add(x)`: -->

スーパークラスのメソッドは`super$xx()`で呼び出せます．以下の例の`CountingQueue`は，これまでにキューに追加されたことのあるオブジェクトの個数を保持します．これは`add()`メソッドをオーバーライドして，カウンタをインクリメントしてからスーパークラスの`add()`メソッドを`super$add(x)`で呼び出すことによって実現されています．


```r
CountingQueue <- R6Class("CountingQueue",
  inherit = Queue,
  public = list(
    add = function(x) {
      private$total <<- private$total + 1
      super$add(x)
    },
    get_total = function() private$total
  ),
  private = list(
    total = 0
  )
)

cq <- CountingQueue$new("x", "y")
cq$get_total()
#> [1] 2
cq$add("z")
cq$remove()
#> [1] "x"
cq$remove()
#> [1] "y"
cq$get_total()
#> [1] 3
```


<!-- ### Fields containing reference objects -->

### 参照オブジェクトを含むフィールド

<!-- If your R6 class contains any fields that also have reference semantics (e.g., other R6 objects, and environments), those fields should be populated in the `initialize` method. If the field set to the reference object directly in the class definition, that object will be shared across all instances of the R6 objects. Here's an example: -->

R6クラスが参照セマンティクスを持つフィールド（たとえば他のR6オブジェクトや環境）を含む場合，それらのフィールドは`initialize()`メソッドで初期化するべきです．もしクラス定義の中で直接それらのフィールドが参照オブジェクトに設定されると，そのオブジェクトがR6オブジェクトのすべてのインスタンスで共有されてしまいます．


```r
SimpleClass <- R6Class("SimpleClass",
  public = list(x = NULL)
)

SharedField <- R6Class("SharedField",
  public = list(
    e = SimpleClass$new()
  )
)

s1 <- SharedField$new()
s1$e$x <- 1

s2 <- SharedField$new()
s2$e$x <- 2
# s2$e$x を変更すると s1$e$x の値も変わってしまう
s1$e$x
#> [1] 2
```
<!-- # Changing s2$e$x has changed the value of s1$e$x -->

<!-- To avoid this, populate the field in the `initialize` method: -->

これを回避するには，フィールドを`initialize()`メソッドで初期化するようにします．


```r
NonSharedField <- R6Class("NonSharedField",
  public = list(
    e = NULL,
    initialize = function() self$e <- SimpleClass$new()
  )
)

n1 <- NonSharedField$new()
n1$e$x <- 1

n2 <- NonSharedField$new()
n2$e$x <- 2
# n2$e$x は n1$e$x には影響を与えない
n1$e$x
#> [1] 1
```
<!-- # n2$e$x does not affect n1$e$x -->

<!-- ## Portable and non-portable classes -->

## 移植可能（portable）クラスと移植不可（non-potable）クラス

<!-- In R6 version 1.0.1, the default was to create **non-portable** classes. In subsequent versions, the default is to create **portable** classes. The two most noticeable differences are that portable classes: -->

R6のバージョン1.0.1はデフォルトでは**移植不可**クラスを作成するようになっていましたが，後続のバージョンではデフォルトで**移植可能**クラスを作成するようになっています．重要な相違点が2つあります．

<!-- * Support inheritance across different packages. Non-portable classes do not do this very well. -->
<!-- * Always require the use of `self` and `private` to access members, as in `self$x` and `private$y`. Non-portable classes can access these members with just `x` and `y`, and do assignment to these members with the `<<-` operator. -->

* 移植可能クラスはパッケージをまたいだ継承をサポートしています．移植不可クラスではこれがうまくできません．
* 移植可能クラスでは，メンバにアクセスするのに必ず`self`と`private`が必要であり，`self$x`や`private$y`のようにしてアクセスします．移植不可クラスでは，こういったメンバには単に`x`や`y`でアクセスでき，代入は`<<-`演算子で行います．

<!-- The implementation of the first point is such that it makes the second point necessary. -->

前者を実装するには後者が必要になります．

<!-- ### Using `self` and `<<-` -->

### `self`と`<<-`の使用

<!-- With reference classes, you can access the field without `self`, and assign to fields using `<<-`. For example: -->

参照クラスではフィールドに`self`なしでアクセスでき，フィールドへの代入は`<<-`を使って行います．以下はその例です．


```r
RC <- setRefClass("RC",
  fields = list(x = 'ANY'),
  methods = list(
    getx = function() x,
    setx = function(value) x <<- value
  )
)

rc <- RC$new()
rc$setx(10)
rc$getx()
#> [1] 10
```

<!-- The same is true for non-portable R6 classes: -->

移植不可のR6クラスも同様です．


```r
NP <- R6Class("NP",
  portable = FALSE,
  public = list(
    x = NA,
    getx = function() x,
    setx = function(value) x <<- value
  )
)

np <- NP$new()
np$setx(10)
np$getx()
#> [1] 10
```

<!-- But for portable R6 classes (this is the default), you must use `self` and/or `private`, and `<<-` assignment doesn't work -- unless you use `self`, of course: -->

しかし，移植可能なR6クラス（これがデフォルトですが）では`self`か`private`を使わなければなりません．`<<-`はうまく動作しません（もちろん，`self`を使わない限りはですが）．


```r
P <- R6Class("P",
  portable = TRUE,  # これがデフォルト
  public = list(
    x = NA,
    getx = function() self$x,
    setx = function(value) self$x <- value
  )
)

p <- P$new()
p$setx(10)
p$getx()
#> [1] 10
```

<!-- For more information, see the Portable vignette. -->
さらなる情報については「移植性」のビネットを見てください．


<!-- ## Other topics -->

## その他のトピック

<!-- ### Adding members to an existing class -->

### 既存のクラスへのメンバ追加

<!-- It is sometimes useful to add members to a class after the class has already been created. This can be done using the `$set()` method on the generator object. -->

クラスが既に作成された後にメンバを追加するのが有用なことがあります．クラスのジェネレータオブジェクトの`$set()`メソッドを使えばこれが可能です．


```r
Simple <- R6Class("Simple",
  public = list(
    x = 1,
    getx = function() self$x
  )
)

Simple$set("public", "getx2", function() self$x*2)

# 既存のメンバを置き換えるには overwrite=TRUE を使う
Simple$set("public", "x", 10, overwrite = TRUE)

s <- Simple$new()
s$x
#> [1] 10
s$getx2()
#> [1] 20
```
<!-- # To replace an existing member, use overwrite=TRUE -->

<!-- The new members will be present only in instances that are created after `$set()` has been called. -->

新たなメンバを持つのは`$set()`を呼び出した後に作成されたインスタンスだけです．

<!-- To prevent modification of a class, you can use `lock_class=TRUE` when creating the class. You can also lock and unlock a class as follows: -->

クラス作成時にクラスの変更を禁止するには`lock_class=TRUE`が使えます．クラスのロックとアンロックは以下のようにすることでも可能です．


```r
# ロックされたクラスの作成
Simple <- R6Class("Simple",
  public = list(
    x = 1,
    getx = function() self$x
  ),
  lock_class = TRUE
)

# これはエラーになる
# Simple$set("public", "y", 2)

# クラスのアンロック
Simple$unlock()

# 今度はきちんと動く
Simple$set("public", "y", 2)

# 再びクラスをロックする
Simple$lock()
```
<!-- # Create a locked class -->
<!-- # This would result in an error -->
<!-- # Unlock the class -->
<!-- # Lock the class again -->

<!-- ### Cloning objects -->

### オブジェクトのクローン

<!-- By default, R6 objects have method named `clone` for making a copy of the object. -->

R6オブジェクトは，オブジェクトのコピーを作るための`clone()`という名前のメソッドをデフォルトで持っています．


```r
Simple <- R6Class("Simple",
  public = list(
    x = 1,
    getx = function() self$x
  )
)

s <- Simple$new()

# クローンを作成
s1 <- s$clone()

# クローンの方を変更
s1$x <- 2
s1$getx()
#> [1] 2

# 元のオブジェクトにはクローンの変更による影響はない
s$getx()
#> [1] 1
```
<!-- # Create a clone -->
<!-- # Modify it -->
<!-- # Original is unaffected by changes to the clone -->



<!-- If you don't want a `clone` method to be added, you can use `cloneable=FALSE` when creating the class. If any loaded R6 object has a `clone` method, that function uses 44.1 kB, but for each additional object, the `clone` method costs a trivial amount of space (112 bytes). -->

`clone()`メソッドが追加されるのがいやであれは，クラス作成時に`cloneable=FALSE`にできます．`clone()`メソッドを持つR6オブジェクトがロードされていると`clone()`関数がメモリを44.1 kB消費しますが，さらにオブジェクトを追加した場合，オブジェクト1つあたりの`clone()`メソッドが消費するメモリはわずかなものです（112バイト）．


<!-- #### Deep cloning -->

#### ディープクローン

<!-- If there are any fields which are objects with reference sematics (environments, R6 objects, reference class objects), the copy will get a reference to the same object. This is sometimes desirable, but often it is not. -->

参照セマンティクスのオブジェクト（環境，R6オブジェクト，参照クラスオブジェクト）を持つフィールドがある場合，コピーされたオブジェクトは，元のオブジェクトのフィールドと同一のオブジェクトへの参照を持つことになります．これは望ましいこともありますが，そうでない場合が多いです．

<!-- For example, we'll create an object `c1` which contains another R6 object, `s`, and then clone it. Because the original's and the clone's `s` fields both refer to the same object, modifying it from one results in a change that is reflect in the other. -->

例として，他のR6オブジェクト`s`を含むようなオブジェクト`c1`を作成し，これをクローンします．元のオブジェクトとクローンの`s`フィールドは両方が同一のオブジェクトを参照しており，一方のフィールドを変更するともう一方
にも変更が反映されます．


```r
Simple <- R6Class("Simple", public = list(x = 1))

Cloneable <- R6Class("Cloneable",
  public = list(
    s = NULL,
    initialize = function() self$s <- Simple$new()
  )
)

c1 <- Cloneable$new()
c2 <- c1$clone()

# c1の`s`フィールドを変更
c1$s$x <- 2

# c2の`s`は同じオブジェクトなので変更が反映される
c2$s$x
#> [1] 2
```
<!-- # Change c1's `s` field -->
<!-- # c2's `s` is the same object, so it reflects the change -->

<!-- To make it so the clone receives a *copy* of `s`, we can use the `deep=TRUE` option: -->
クローンが`s`の**コピー**を受け取れるようにするには，`deep=TRUE`オプションが使えます．


```r
c3 <- c1$clone(deep = TRUE)

# Change c1's `s` field
c1$s$x <- 3

# c2's `s` is different
c3$s$x
#> [1] 2
```

<!-- The default behavior of `clone(deep=TRUE)` is to copy fields which are R6 objects, but not copy fields which are environments, reference class objects, or other data structures which contain other reference-type objects (for example, a list with an R6 object). -->

`clone(deep=TRUE)`のデフォルトのふるまいは，R6オブジェクトのフィールドをコピーするようになっています．ですが，環境や参照クラスオブジェクト，その他のデータ構造で参照セマンティクスのオブジェクトを含むもののフィールドはコピーしません（たとえばR6オブジェクトを含むリスト）．

<!-- If your R6 object contains these types of objects and you want to make a deep clone of them, you must provide your own function for deep cloning, in a private method named `deep_clone`. Below is an example of an R6 object with two fields, `a` and `b`, both of which which are environments, and both of which contain a value `x`. It also has a field `v` which is a regular (non-reference) value, and a private `deep_clone` method. -->

R6オブジェクトがこういった種類のオブジェクトを含んでおり，それらをディープクローンしたい場合には，自分でそのための関数をプライベートメソッドの`deep_clone()`で提供しなければなりません．以下は，環境からなる2つのフィールド`a`，`b`を持ち，さらにその2つのフィールドが値`x`を持つようなR6オブジェクトの例です．このオブジェクトには，通常の（参照でない）値を持つフィールド`v`と，プライベートな`deep_clone()`メソッドもあります．

<!-- The `deep_clone` method is be called once for each field. It is passed the name and value of the field, and the value it returns is be used in the clone. -->

`deep_clone()`メソッドは各フィールドに対して一度ずつ呼び出されます．フィールドの名前と値がメソッドに渡され，その戻り値がクローンで使われます．


```r
CloneEnv <- R6Class("CloneEnv",
  public = list(
    a = NULL,
    b = NULL,
    v = 1,
    initialize = function() {
      self$a <- new.env(parent = emptyenv())
      self$b <- new.env(parent = emptyenv())
      self$a$x <- 1
      self$b$x <- 1
    }
  ),
  private = list(
    deep_clone = function(name, value) {
      # x$clone(deep=TRUE) が呼び出されると，deep_clone() が
      # 各フィールドに対して一度ずつ，name と value を引数にして実行される
      if (name == "a") {
        # `a` は環境なので，こうやってコピーするのがてっとり早い
        list2env(as.list.environment(value, all.names = TRUE),
                 parent = emptyenv())
      } else {
        # 他のフィールドに対しては単に値を返すようにする
        value
      }
    }
  )
)

c1 <- CloneEnv$new()
c2 <- c1$clone(deep = TRUE)
```
<!-- # With x$clone(deep=TRUE) is called, the deep_clone gets invoked once for -->
<!-- # each field, with the name and value. -->
<!-- # `a` is an environment, so use this quick way of copying -->
<!-- # For all other fields, just return the value -->

<!-- When `c1$clone(deep=TRUE)` is called, the `deep_clone` method is called for each field in `c1`, and is passed the name of the field and value. In our version, the `a` environment gets copied, but `b` does not, nor does `v` (but that doesn't matter since `v` is not a reference object). We can test out the clone: -->

`c1$clone(deep=TRUE)`が呼び出されると，`deep_clone()`メソッドが`c1`の各フィールドに対して呼び出され，フィールドの名前と値が引数として渡されます．この例のバージョンでは，環境`a`はコピーされるが環境`b`はコピーされず，`v`もコピーされないようになっています（といっても`v`は参照オブジェクトではないので関係ありませんが）．


```r
# c1$aを変更してもc2$aは別のオブジェクトなので影響はない
c1$a$x <- 2
c2$a$x
#> [1] 1

# c1$bを変更するとc2$bも同じオブジェクトなので影響がある
c1$b$x <- 3
c2$b$x
#> [1] 3

# c1$vを変更しても参照オブジェクトではないのでc2$vに影響はない
c1$v <- 4
c2$v
#> [1] 1
```
<!-- # Modifying c1$a doesn't affect c2$a, because they're separate objects -->
<!-- # Modifying c1$b does affect c2$b, because they're the same object -->
<!-- # Modifying c1$v doesn't affect c2$v, because they're not reference objects -->

<!-- In the example `deep_clone` method above, we checked the name of each field to determine what to do with it, but we could also check the value, by using `inherits(value, "R6")`, or `is.environment()`, and so on. -->

この例の`deep_clone()`メソッドでは処理内容を決めるために各フィールドの名前をチェックしていますが，`inherits(value, "R6")`や`is.environment()`などを使って，値の方をチェックすることもできるでしょう．

<!-- ### Printing R6 objects to the screen -->

### R6オブジェクトの表示

<!-- R6 objects have a default `print` method that lists all members of the object. -->
<!-- If a class defines a `print` method, then it overrides the default one. -->

R6オブジェクトにはデフォルトの`print()`メソッドがあり，オブジェクトのすべてのメンバの一覧を表示するようになっています．クラスで`print()`メソッドを定義してやれば，デフォルトのメソッドをオーバーライドできます．


```r
PrettyCountingQueue <- R6Class("PrettyCountingQueue",
  inherit = CountingQueue,
  public = list(
    print = function(...) {
      cat("<PrettyCountingQueue> of ", self$get_total(), " elements\n", sep = "")
      invisible(self)
    }
  )
)
```


```r
pq <- PrettyCountingQueue$new(1, 2, "foobar")
pq
#> <PrettyCountingQueue> of 3 elements
```

<!-- ### Finalizers -->

### ファイナライザ

<!-- Sometimes it's useful to run a function when the object is garbage collected. For example, you may want to make sure a file or database connection gets closed. To do this, you can define a `finalize()` method, which will be called with no arguments when the object is garbage collected. -->

オブジェクトがガベージコレクトされた際に関数を実行するのが有用な場合があります．たとえば，ファイルやデータベースへの接続が閉じるように保証したいことがあるかもしれません．こういった用途のために`finalize()`メソッドを定義することができます．`finalize()`メソッドはオブジェクトがガベージコレクトされた時に引数なしで呼び出されます．


```r
A <- R6Class("A", public = list(
  finalize = function() {
    print("Finalizer has been called!")
  }
))

# オブジェクトのインスタンス化
obj <- A$new()

# オブジェクトに対して存在している唯一の参照を削除し，
# 強制的にガベージコレクションを実行する
# （通常，ガベージコレクションは自動的に時々実行される）
rm(obj); gc()
#> [1] "Finalizer has been called!"
#>          used (Mb) gc trigger (Mb) max used (Mb)
#> Ncells 405575 21.7     750400 40.1   592000 31.7
#> Vcells 628036  4.8    1308461 10.0   913159  7.0
```
<!-- # Instantiate an object: -->
<!-- # Remove the single existing reference to it, and force garbage collection -->
<!-- # (normally garbage collection will happen automatically from time -->
<!-- # to time) -->

<!-- Finalizers are implemented using the `reg.finalizer()` function, and they set `onexit=TRUE`, so that the finalizer will also be called when R exits. This is useful in some cases, like database connections. -->

ファイナライザは`reg.finalizer()`関数を用いて実装されており，Rセッションが終了した時にもファイナライザが呼び出されるよう，`onexit=TRUE`に設定されています．これはデータベース接続などの場合に有用です．

<!-- ## Summary -->

## まとめ

<!-- R6 classes provide capabilities that are common in other object-oriented programming languages. They're similar to R's built-in reference classes, but are simpler, smaller, and faster, and they allow inheritance across packages. -->

R6クラスは他のオブジェクト指向プログラミング言語で一般的な機能を提供します．Rに組み込みの参照クラスと似ていますが，より単純・軽量・高速で，パッケージをまたいだ継承が可能です．

----

訳注：翻訳の際，コードは以下の環境で実行した．


```r
devtools::session_info()
#> Session info --------------------------------------------------------------
#>  setting  value                       
#>  version  R version 3.3.2 (2016-10-31)
#>  system   x86_64, mingw32             
#>  ui       RTerm                       
#>  language (EN)                        
#>  collate  Japanese_Japan.932          
#>  tz       Asia/Tokyo                  
#>  date     2017-01-15
#> Packages ------------------------------------------------------------------
#>  package   * version date       source        
#>  backports   1.0.4   2016-10-24 CRAN (R 3.3.2)
#>  codetools   0.2-15  2016-10-05 CRAN (R 3.3.2)
#>  devtools    1.12.0  2016-06-24 CRAN (R 3.3.2)
#>  digest      0.6.10  2016-08-02 CRAN (R 3.3.2)
#>  evaluate    0.10    2016-10-11 CRAN (R 3.3.2)
#>  htmltools   0.3.5   2016-03-21 CRAN (R 3.3.1)
#>  knitr       1.15.1  2016-11-22 CRAN (R 3.3.2)
#>  magrittr    1.5     2014-11-22 CRAN (R 3.3.1)
#>  memoise     1.0.0   2016-01-29 CRAN (R 3.3.1)
#>  pryr      * 0.1.2   2015-06-20 CRAN (R 3.3.2)
#>  R6        * 2.2.0   2016-10-05 CRAN (R 3.3.2)
#>  Rcpp        0.12.8  2016-11-17 CRAN (R 3.3.2)
#>  rmarkdown   1.2     2016-11-21 CRAN (R 3.3.2)
#>  rprojroot   1.1     2016-10-29 CRAN (R 3.3.2)
#>  stringi     1.1.2   2016-10-01 CRAN (R 3.3.2)
#>  stringr     1.1.0   2016-08-19 CRAN (R 3.3.2)
#>  withr       1.0.2   2016-06-20 CRAN (R 3.3.1)
#>  yaml        2.1.14  2016-11-12 CRAN (R 3.3.2)
```