diff --git a/implementations/rust/preserves/src/value/packed/mod.rs b/implementations/rust/preserves/src/value/packed/mod.rs
index 0417aac..94bee65 100644
--- a/implementations/rust/preserves/src/value/packed/mod.rs
+++ b/implementations/rust/preserves/src/value/packed/mod.rs
@@ -9,7 +9,7 @@ use std::io;
 
 use super::{BinarySource, DomainDecode, IOValue, IOValueDomainCodec, NestedValue, Reader};
 
-pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::D>>(
+pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
     bs: &[u8],
     decode_embedded: Dec,
 ) -> io::Result<N> {
@@ -20,7 +20,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result<IOValue> {
     from_bytes(bs, IOValueDomainCodec)
 }
 
-pub fn annotated_from_bytes<N: NestedValue, Dec: DomainDecode<N::D>>(
+pub fn annotated_from_bytes<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
     bs: &[u8],
     decode_embedded: Dec,
 ) -> io::Result<N> {
diff --git a/implementations/rust/preserves/src/value/packed/reader.rs b/implementations/rust/preserves/src/value/packed/reader.rs
index 2b1efb8..388fef0 100644
--- a/implementations/rust/preserves/src/value/packed/reader.rs
+++ b/implementations/rust/preserves/src/value/packed/reader.rs
@@ -30,13 +30,13 @@ use super::super::{
     signed_integer::SignedInteger,
 };
 
-pub struct PackedReader<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> {
+pub struct PackedReader<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>> {
     pub source: &'src mut S,
     pub decode_embedded: Dec,
     phantom: PhantomData<&'de N>,
 }
 
-impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>>
+impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>>
     BinarySource<'de>
     for PackedReader<'de, 'src, N, Dec, S>
 {
@@ -65,7 +65,7 @@ fn out_of_range<I: Into<BigInt>>(i: I) -> error::Error {
     error::Error::NumberOutOfRange(i.into())
 }
 
-impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> PackedReader<'de, 'src, N, Dec, S> {
+impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>> PackedReader<'de, 'src, N, Dec, S> {
     pub fn new(source: &'src mut S, decode_embedded: Dec) -> Self {
         PackedReader { source, decode_embedded, phantom: PhantomData }
     }
@@ -257,7 +257,7 @@ impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> P
     }
 }
 
-impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>>
+impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>>
     Reader<'de, N>
     for PackedReader<'de, 'src, N, Dec, S>
 {
diff --git a/implementations/rust/preserves/src/value/packed/writer.rs b/implementations/rust/preserves/src/value/packed/writer.rs
index c656570..6a0953f 100644
--- a/implementations/rust/preserves/src/value/packed/writer.rs
+++ b/implementations/rust/preserves/src/value/packed/writer.rs
@@ -16,7 +16,7 @@ use super::super::writer::{Writer, CompoundWriter, varint};
 pub struct PackedWriter<W: io::Write>(Suspendable<W>);
 
 impl PackedWriter<&mut Vec<u8>> {
-    pub fn encode<N: NestedValue, Enc: DomainEncode<N::D>>(
+    pub fn encode<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
         enc: &mut Enc,
         v: &N,
     ) -> io::Result<Vec<u8>> {
diff --git a/implementations/rust/preserves/src/value/reader.rs b/implementations/rust/preserves/src/value/reader.rs
index 9940288..72d583c 100644
--- a/implementations/rust/preserves/src/value/reader.rs
+++ b/implementations/rust/preserves/src/value/reader.rs
@@ -19,7 +19,7 @@ use super::signed_integer::SignedInteger;
 pub type ReaderResult<T> = std::result::Result<T, error::Error>;
 
 pub enum Token<N: NestedValue> {
-    Embedded(N::D),
+    Embedded(N::Embedded),
     Atom(N),
     Compound(CompoundClass),
     End,
@@ -229,7 +229,7 @@ pub trait BinarySource<'de>: Sized {
     fn readbytes(&mut self, count: usize) -> io::Result<Cow<'de, [u8]>>;
     fn readbytes_into(&mut self, bs: &mut [u8]) -> io::Result<()>;
 
-    fn packed<N: NestedValue, Dec: DomainDecode<N::D>>(
+    fn packed<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
         &mut self,
         decode_embedded: Dec,
     ) -> super::PackedReader<'de, '_, N, Dec, Self> {
@@ -242,10 +242,10 @@ pub trait BinarySource<'de>: Sized {
         self.packed(IOValueDomainCodec)
     }
 
-    fn text<N: NestedValue, Dec: DomainParse<N::D>>(
+    fn text<N: NestedValue, Dec: DomainParse<N::Embedded>>(
         &mut self,
         decode_embedded: Dec,
-    ) -> super::TextReader<'de, '_, N::D, Dec, Self> {
+    ) -> super::TextReader<'de, '_, N::Embedded, Dec, Self> {
         super::TextReader::new(self, decode_embedded)
     }
 
diff --git a/implementations/rust/preserves/src/value/repr.rs b/implementations/rust/preserves/src/value/repr.rs
index baeac36..d41e66b 100644
--- a/implementations/rust/preserves/src/value/repr.rs
+++ b/implementations/rust/preserves/src/value/repr.rs
@@ -26,13 +26,13 @@ impl<T> Embeddable for T where T: Domain + Clone {}
 impl<D: Domain> Domain for Arc<D> {}
 
 pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
-    type D: Embeddable;
+    type Embedded: Embeddable;
 
     fn new<V>(v: V) -> Self where Value<Self>: From<V> {
         Value::from(v).wrap()
     }
 
-    fn domain<E>(e: E) -> Self where Self::D: From<E> {
+    fn domain<E>(e: E) -> Self where Self::Embedded: From<E> {
         Value::Embedded(e.into()).wrap()
     }
 
@@ -64,14 +64,14 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
 
     fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<M, Err>
     where
-        F: FnMut(&Self::D) -> Result<Value<M>, Err>
+        F: FnMut(&Self::Embedded) -> Result<Value<M>, Err>
     {
         Ok(M::wrap(self.annotations().copy_via(f)?, self.value().copy_via(f)?))
     }
 
     fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err>
     where
-        F: FnMut(&Self::D) -> Result<(), Err>
+        F: FnMut(&Self::Embedded) -> Result<(), Err>
     {
         match &self.annotations().0 {
             None => (),
@@ -95,7 +95,7 @@ pub enum Value<N: NestedValue> {
     Sequence(Vec<N>),
     Set(Set<N>),
     Dictionary(Map<N, N>),
-    Embedded(N::D),
+    Embedded(N::Embedded),
 }
 
 /// The kinds of `Value` from the specification.
@@ -905,7 +905,7 @@ impl<N: NestedValue> Value<N> {
         self.as_embedded().is_some()
     }
 
-    pub fn as_embedded(&self) -> Option<&N::D> {
+    pub fn as_embedded(&self) -> Option<&N::Embedded> {
         if let Value::Embedded(d) = self {
             Some(d)
         } else {
@@ -913,13 +913,13 @@ impl<N: NestedValue> Value<N> {
         }
     }
 
-    pub fn to_embedded(&self) -> Result<&N::D, Error> {
+    pub fn to_embedded(&self) -> Result<&N::Embedded, Error> {
         self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded))
     }
 
     pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Value<M>, Err>
     where
-        F: FnMut(&N::D) -> Result<Value<M>, Err>
+        F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
     {
         Ok(match self {
             Value::Boolean(b) => Value::Boolean(*b),
@@ -945,7 +945,7 @@ impl<N: NestedValue> Value<N> {
 
     pub fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err>
     where
-        F: FnMut(&N::D) -> Result<(), Err>
+        F: FnMut(&N::Embedded) -> Result<(), Err>
     {
         match self {
             Value::Boolean(_) |
@@ -1045,7 +1045,7 @@ impl<N: NestedValue> Annotations<N> {
 
     pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Annotations<M>, Err>
     where
-        F: FnMut(&N::D) -> Result<Value<M>, Err>
+        F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
     {
         Ok(match &self.0 {
             None =>
@@ -1109,7 +1109,7 @@ impl<D: Embeddable> PlainValue<D> {
 }
 
 impl<D: Embeddable> NestedValue for PlainValue<D> {
-    type D = D;
+    type Embedded = D;
 
     fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
         PlainValue(AnnotatedValue::new(anns, v))
@@ -1147,7 +1147,7 @@ use std::rc::Rc;
 pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>>>);
 
 impl<D: Embeddable> NestedValue for RcValue<D> {
-    type D = D;
+    type Embedded = D;
 
     fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
         RcValue(Rc::new(AnnotatedValue::new(anns, v)))
@@ -1185,7 +1185,7 @@ impl<D: Embeddable> Debug for RcValue<D> {
 pub struct ArcValue<D: Embeddable>(Arc<AnnotatedValue<ArcValue<D>>>);
 
 impl<D: Embeddable> NestedValue for ArcValue<D> {
-    type D = D;
+    type Embedded = D;
 
     fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
         ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
@@ -1226,7 +1226,7 @@ pub type UnwrappedIOValue = Value<IOValue>;
 impl Domain for IOValue {}
 
 impl NestedValue for IOValue {
-    type D = Self;
+    type Embedded = Self;
 
     fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
         IOValue(Arc::new(AnnotatedValue::new(anns, v)))
@@ -1291,7 +1291,7 @@ impl<D: Embeddable> DummyValue<D> {
 }
 
 impl<D: Embeddable> NestedValue for DummyValue<D> {
-    type D = D;
+    type Embedded = D;
 
     fn wrap(_anns: Annotations<Self>, _v: Value<Self>) -> Self {
         DummyValue::new()
diff --git a/implementations/rust/preserves/src/value/text/mod.rs b/implementations/rust/preserves/src/value/text/mod.rs
index 5ecc258..94921ee 100644
--- a/implementations/rust/preserves/src/value/text/mod.rs
+++ b/implementations/rust/preserves/src/value/text/mod.rs
@@ -10,7 +10,7 @@ use std::io;
 
 use super::{DomainParse, IOValue, IOValueDomainCodec, NestedValue, Reader, ViaCodec};
 
-pub fn from_str<N: NestedValue, Dec: DomainParse<N::D>>(
+pub fn from_str<N: NestedValue, Dec: DomainParse<N::Embedded>>(
     s: &str,
     decode_embedded: Dec,
 ) -> io::Result<N> {
@@ -21,7 +21,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
     from_str(s, ViaCodec::new(IOValueDomainCodec))
 }
 
-pub fn annotated_from_str<N: NestedValue, Dec: DomainParse<N::D>>(
+pub fn annotated_from_str<N: NestedValue, Dec: DomainParse<N::Embedded>>(
     s: &str,
     decode_embedded: Dec,
 ) -> io::Result<N> {
diff --git a/implementations/rust/preserves/src/value/text/reader.rs b/implementations/rust/preserves/src/value/text/reader.rs
index fbb1a51..446d3e8 100644
--- a/implementations/rust/preserves/src/value/text/reader.rs
+++ b/implementations/rust/preserves/src/value/text/reader.rs
@@ -89,14 +89,14 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
     }
 
     // TODO: This is a duplicate of fn expected in PackedReader.
-    fn expected<N: NestedValue<D = D>>(&mut self, k: ExpectedKind) -> Error {
+    fn expected<N: NestedValue<Embedded = D>>(&mut self, k: ExpectedKind) -> Error {
         match Reader::<N>::demand_next(self, true) {
             Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))),
             Err(e) => e.into()
         }
     }
 
-    fn gather_annotations<N: NestedValue<D = D>>(&mut self) -> ReaderResult<Vec<N>> {
+    fn gather_annotations<N: NestedValue<Embedded = D>>(&mut self) -> ReaderResult<Vec<N>> {
         let mut vs = Vec::new();
         loop {
             self.skip_whitespace();
@@ -334,7 +334,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
         }
     }
 
-    fn upto<N: NestedValue<D = D>>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result<Vec<N>> {
+    fn upto<N: NestedValue<Embedded = D>>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result<Vec<N>> {
         let mut vs = Vec::new();
         loop {
             self.skip_whitespace();
@@ -346,7 +346,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
         }
     }
 
-    fn read_dictionary<N: NestedValue<D = D>>(&mut self, read_annotations: bool) -> io::Result<N> {
+    fn read_dictionary<N: NestedValue<Embedded = D>>(&mut self, read_annotations: bool) -> io::Result<N> {
         let mut d = Map::new();
         loop {
             self.skip_whitespace();
@@ -385,8 +385,8 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
     }
 }
 
-impl<'de, 'src, N: NestedValue, Dec: DomainParse<N::D>, S: BinarySource<'de>>
-    Reader<'de, N> for TextReader<'de, 'src, N::D, Dec, S>
+impl<'de, 'src, N: NestedValue, Dec: DomainParse<N::Embedded>, S: BinarySource<'de>>
+    Reader<'de, N> for TextReader<'de, 'src, N::Embedded, Dec, S>
 {
     fn next(&mut self, read_annotations: bool) -> io::Result<Option<N>> {
         self.skip_whitespace();
diff --git a/implementations/rust/preserves/src/value/text/writer.rs b/implementations/rust/preserves/src/value/text/writer.rs
index 06cc779..a1d2217 100644
--- a/implementations/rust/preserves/src/value/text/writer.rs
+++ b/implementations/rust/preserves/src/value/text/writer.rs
@@ -34,7 +34,7 @@ impl std::default::Default for CommaStyle {
 }
 
 impl TextWriter<&mut Vec<u8>> {
-    pub fn encode<N: NestedValue, Enc: DomainEncode<N::D>>(
+    pub fn encode<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
         enc: &mut Enc,
         v: &N,
     ) -> io::Result<String> {
diff --git a/implementations/rust/preserves/src/value/writer.rs b/implementations/rust/preserves/src/value/writer.rs
index 9fc37f1..bbd222e 100644
--- a/implementations/rust/preserves/src/value/writer.rs
+++ b/implementations/rust/preserves/src/value/writer.rs
@@ -58,7 +58,7 @@ pub trait Writer: Sized {
 
     //---------------------------------------------------------------------------
 
-    fn write<N: NestedValue, Enc: DomainEncode<N::D>>(
+    fn write<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
         &mut self,
         enc: &mut Enc,
         v: &N,
@@ -86,7 +86,7 @@ pub trait Writer: Sized {
         Ok(())
     }
 
-    fn write_value<N: NestedValue, Enc: DomainEncode<N::D>>(
+    fn write_value<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
         &mut self,
         enc: &mut Enc,
         v: &Value<N>,