diff --git a/R/RcppExports.R b/R/RcppExports.R
index 7419159..c1c57d8 100644
--- a/R/RcppExports.R
+++ b/R/RcppExports.R
@@ -41,8 +41,8 @@ bitset_or <- function(a, b) {
     invisible(.Call(`_individual_bitset_or`, a, b))
 }
 
-bitset_assign <- function(a, b) {
-    invisible(.Call(`_individual_bitset_assign`, a, b))
+bitset_copy_from <- function(a, b) {
+    invisible(.Call(`_individual_bitset_copy_from`, a, b))
 }
 
 bitset_xor <- function(a, b) {
diff --git a/R/bitset.R b/R/bitset.R
index f18e829..aa94e73 100644
--- a/R/bitset.R
+++ b/R/bitset.R
@@ -108,17 +108,6 @@ Bitset <- list(
         self
       },
 
-      #' ```{r echo=FALSE, results="asis"}
-      #' bitset_method_doc(
-      #'   "assign",
-      #'   "overwrite the value of a bitset from another bitset",
-      #'   other = "the other bitset.")
-      #' ```
-      assign = function(other) {
-        bitset_assign(self$.bitset, other$.bitset)
-        self
-      },
-
       #' ```{r echo=FALSE, results="asis"}
       #' bitset_method_doc(
       #'   "size",
@@ -221,10 +210,28 @@ Bitset <- list(
       #' ```{r echo=FALSE, results="asis"}
       #' bitset_method_doc(
       #'   "copy",
-      #'   "returns a copy of the bitset.")
+      #'   "returns a copy of the bitset.
+      #'
+      #'    In cases where a destination bitset already exists, it may be more
+      #'    performant to use the \\code{copy_from} method instead.")
       #' ```
       copy = function() Bitset$new(from = bitset_copy(self$.bitset)),
 
+
+      #' ```{r echo=FALSE, results="asis"}
+      #' bitset_method_doc(
+      #'   "copy_from",
+      #'   "overwrite the value of the bitset from another bitset.
+      #'
+      #'    This is similar to calling \\code{other$copy()}, but can be more
+      #'    efficient by reusing the resources of the existing bitset.",
+      #'   other = "the other bitset.")
+      #' ```
+      copy_from = function(other) {
+        bitset_copy_from(self$.bitset, other$.bitset)
+        self
+      },
+
       #' ```{r echo=FALSE, results="asis"}
       #' bitset_method_doc(
       #'   "to_vector",
diff --git a/man/Bitset.Rd b/man/Bitset.Rd
index b4c8b25..22b97c9 100644
--- a/man/Bitset.Rd
+++ b/man/Bitset.Rd
@@ -61,18 +61,6 @@ clear the bitset.
 }
 }
 \if{html}{\out{<hr>}}
-\subsection{Method \code{assign()}}{
-overwrite the value of a bitset from another bitset
-\subsection{Usage}{
-\preformatted{b$assign(other)}
-}
-\subsection{Arguments}{
-\describe{
-\item{\code{other}}{the other bitset.}
-}
-}
-}
-\if{html}{\out{<hr>}}
 \subsection{Method \code{size()}}{
 get the number of elements in the set.
 \subsection{Usage}{
@@ -172,11 +160,29 @@ k should be chosen such that \eqn{0 \le k \le N}.}
 \if{html}{\out{<hr>}}
 \subsection{Method \code{copy()}}{
 returns a copy of the bitset.
+
+In cases where a destination bitset already exists, it may be more
+performant to use the \code{copy_from} method instead.
 \subsection{Usage}{
 \preformatted{b$copy()}
 }
 }
 \if{html}{\out{<hr>}}
+\subsection{Method \code{copy_from()}}{
+overwrite the value of the bitset from another bitset.
+
+This is similar to calling \code{other$copy()}, but can be more
+efficient by reusing the resources of the existing bitset.
+\subsection{Usage}{
+\preformatted{b$copy_from(other)}
+}
+\subsection{Arguments}{
+\describe{
+\item{\code{other}}{the other bitset.}
+}
+}
+}
+\if{html}{\out{<hr>}}
 \subsection{Method \code{to_vector()}}{
 return an integer vector of the elements stored in this bitset.
 \subsection{Usage}{
diff --git a/man/restore_object_state.Rd b/man/restore_object_state.Rd
index f9a600a..8d79701 100644
--- a/man/restore_object_state.Rd
+++ b/man/restore_object_state.Rd
@@ -27,5 +27,7 @@ and the \code{restore_state} method of each object is called.
 If the list of object is named, more objects may be specified than were
 originally present in the saved simulation, allowing a simulation to be
 extended with more features upon resuming. In this case, the
-\code{restore_state} method is called with a \code{NULL} argument.
+\code{restore_state} method of the new objects is called with a \code{NULL}
+argument. Conversly, the list of objects may omit certain entries, in which
+case their state to be restored is ignored.
 }
diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp
index f8a76a1..86132a3 100644
--- a/src/RcppExports.cpp
+++ b/src/RcppExports.cpp
@@ -124,14 +124,14 @@ BEGIN_RCPP
     return R_NilValue;
 END_RCPP
 }
-// bitset_assign
-void bitset_assign(const Rcpp::XPtr<individual_index_t> a, const Rcpp::XPtr<individual_index_t> b);
-RcppExport SEXP _individual_bitset_assign(SEXP aSEXP, SEXP bSEXP) {
+// bitset_copy_from
+void bitset_copy_from(const Rcpp::XPtr<individual_index_t> a, const Rcpp::XPtr<individual_index_t> b);
+RcppExport SEXP _individual_bitset_copy_from(SEXP aSEXP, SEXP bSEXP) {
 BEGIN_RCPP
     Rcpp::RNGScope rcpp_rngScope_gen;
     Rcpp::traits::input_parameter< const Rcpp::XPtr<individual_index_t> >::type a(aSEXP);
     Rcpp::traits::input_parameter< const Rcpp::XPtr<individual_index_t> >::type b(bSEXP);
-    bitset_assign(a, b);
+    bitset_copy_from(a, b);
     return R_NilValue;
 END_RCPP
 }
@@ -1475,7 +1475,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_individual_bitset_and", (DL_FUNC) &_individual_bitset_and, 2},
     {"_individual_bitset_not", (DL_FUNC) &_individual_bitset_not, 2},
     {"_individual_bitset_or", (DL_FUNC) &_individual_bitset_or, 2},
-    {"_individual_bitset_assign", (DL_FUNC) &_individual_bitset_assign, 2},
+    {"_individual_bitset_copy_from", (DL_FUNC) &_individual_bitset_copy_from, 2},
     {"_individual_bitset_xor", (DL_FUNC) &_individual_bitset_xor, 2},
     {"_individual_bitset_set_difference", (DL_FUNC) &_individual_bitset_set_difference, 2},
     {"_individual_bitset_sample", (DL_FUNC) &_individual_bitset_sample, 2},
diff --git a/src/bitset.cpp b/src/bitset.cpp
index 01feb96..c6854f6 100644
--- a/src/bitset.cpp
+++ b/src/bitset.cpp
@@ -89,7 +89,7 @@ void bitset_or(
 }
 
 //[[Rcpp::export]]
-void bitset_assign(
+void bitset_copy_from(
     const Rcpp::XPtr<individual_index_t> a,
     const Rcpp::XPtr<individual_index_t> b
     ) {
diff --git a/tests/testthat/test-bitset.R b/tests/testthat/test-bitset.R
index eb3ae2a..606cb0e 100644
--- a/tests/testthat/test-bitset.R
+++ b/tests/testthat/test-bitset.R
@@ -80,13 +80,13 @@ test_that("bitset or works", {
   expect_equal(a$to_vector(), c(1, 3, 5, 6, 7))
 })
 
-test_that("bitset assign works", {
+test_that("bitset copy from works", {
   a <- Bitset$new(10)
   a$insert(c(1, 5, 6))
   b <- Bitset$new(10)
   b$insert(c(1, 3, 7))
 
-  a$assign(b)
+  a$copy_from(b)
   expect_equal(a$to_vector(), c(1, 3, 7))
 
   # Check the two bitsets aren't aliases of each other.
@@ -95,13 +95,13 @@ test_that("bitset assign works", {
   expect_equal(b$to_vector(), numeric(0))
 })
 
-test_that("bitset assign requires bitsets to have same max size", {
+test_that("bitset copy from requires bitsets to have same max size", {
   a <- Bitset$new(8)
   a$insert(c(1, 5, 6))
   b <- Bitset$new(10)
   b$insert(c(1, 3, 7))
 
-  expect_error(a$assign(b), "Incompatible bitmap sizes")
+  expect_error(a$copy_from(b), "Incompatible bitmap sizes")
 })