diff --git a/implementations/rust/src/value/de.rs b/implementations/rust/src/value/de.rs
index 7b1f12e..d695184 100644
--- a/implementations/rust/src/value/de.rs
+++ b/implementations/rust/src/value/de.rs
@@ -79,7 +79,7 @@ impl<'de, N: NestedValue<D>, D: 'de + Domain> Deserializer<'de, N, D> {
     fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T, D>
     where F: FnOnce(&'de Value<N, D>) -> Option<T>
     {
-        f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via()))
+        f(self.input.value()).ok_or_else(|| Error::Expected(k, self.input.copy_via_id()))
     }
 }
 
@@ -191,7 +191,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
         let fs = self.check(|v| v.as_simple_record("UnicodeScalar", Some(1)),
                             ExpectedKind::SimpleRecord("UnicodeScalar", Some(1)))?;
         let c = fs[0].value().as_u32()
-            .ok_or_else(|| Error::Expected(ExpectedKind::SignedInteger, self.input.copy_via()))?;
+            .ok_or_else(|| Error::Expected(ExpectedKind::SignedInteger, self.input.copy_via_id()))?;
         visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?)
     }
 
@@ -224,7 +224,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
                     self.input = &fs[0];
                     visitor.visit_some(self)
                 }
-                None => Err(Error::Expected(ExpectedKind::Option, self.input.copy_via()))
+                None => Err(Error::Expected(ExpectedKind::Option, self.input.copy_via_id()))
             }
         }
     }
@@ -234,7 +234,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
         if self.input.value().is_simple_record("tuple", Some(0)) {
             visitor.visit_unit()
         } else {
-            Err(Error::Expected(ExpectedKind::SimpleRecord("tuple", Some(0)), self.input.copy_via()))
+            Err(Error::Expected(ExpectedKind::SimpleRecord("tuple", Some(0)), self.input.copy_via_id()))
         }
     }
 
@@ -244,7 +244,7 @@ impl<'de, 'a, N: NestedValue<D>, D: 'de + Domain> serde::de::Deserializer<'de>
         if self.input.value().is_simple_record(name, Some(0)) {
             visitor.visit_unit()
         } else {
-            Err(Error::Expected(ExpectedKind::SimpleRecord(name, Some(0)), self.input.copy_via()))
+            Err(Error::Expected(ExpectedKind::SimpleRecord(name, Some(0)), self.input.copy_via_id()))
         }
     }
 
diff --git a/implementations/rust/src/value/value.rs b/implementations/rust/src/value/value.rs
index 5acc8fe..bf76ce5 100644
--- a/implementations/rust/src/value/value.rs
+++ b/implementations/rust/src/value/value.rs
@@ -46,9 +46,16 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
         self.value().fmt(f)
     }
 
-    fn copy_via<M: NestedValue<D>>(&self) -> M {
-        M::wrap_ann(self.annotations().iter().map(|a| a.copy_via()).collect(),
-                    self.value().copy_via())
+    fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> M
+    where
+        F: Fn(&D) -> Value<M, E>
+    {
+        M::wrap_ann(self.annotations().iter().map(|a| a.copy_via(f)).collect(),
+                    self.value().copy_via(f))
+    }
+
+    fn copy_via_id<M: NestedValue<D>,>(&self) -> M {
+        self.copy_via(&|d| Value::Domain(d.clone()))
     }
 }
 
@@ -504,7 +511,10 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
         }
     }
 
-    pub fn copy_via<M: NestedValue<D>>(&self) -> Value<M, D> {
+    pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> Value<M, E>
+    where
+        F: Fn(&D) -> Value<M, E>
+    {
         match self {
             Value::Boolean(b) => Value::Boolean(*b),
             Value::Float(f) => Value::Float(f.clone()),
@@ -514,12 +524,13 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
             Value::ByteString(ref v) => Value::ByteString(v.clone()),
             Value::Symbol(ref v) => Value::Symbol(v.clone()),
             Value::Record((ref l, ref fs)) =>
-                Value::Record((N::boxunwrap(l).copy_via::<M>().boxwrap(), fs.iter().map(|a| a.copy_via()).collect())),
-            Value::Sequence(ref v) => Value::Sequence(v.iter().map(|a| a.copy_via()).collect()),
-            Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via()).collect()),
+                Value::Record((N::boxunwrap(l).copy_via::<M,E,F>(f).boxwrap(),
+                               fs.iter().map(|a| a.copy_via(f)).collect())),
+            Value::Sequence(ref v) => Value::Sequence(v.iter().map(|a| a.copy_via(f)).collect()),
+            Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via(f)).collect()),
             Value::Dictionary(ref v) =>
-                Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(), b.copy_via())).collect()),
-            Value::Domain(d) => Value::Domain(d.clone()),
+                Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(f), b.copy_via(f))).collect()),
+            Value::Domain(d) => f(d),
         }
     }
 }