diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs
index c174e2f..f44680c 100644
--- a/implementations/rust/preserves-schema/src/compiler/mod.rs
+++ b/implementations/rust/preserves-schema/src/compiler/mod.rs
@@ -127,7 +127,7 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
         lines.push("#![allow(unused_imports)]".to_owned());
         lines.push("".to_owned());
         lines.push("use std::convert::TryFrom;".to_owned());
-        lines.push("use preserves::value::Domain;".to_owned());
+        lines.push("use preserves::value::Embeddable;".to_owned());
         lines.push("use preserves::value::NestedValue;".to_owned());
         lines.push(format!("use {}::support as _support;", &config.support_crate));
         lines.push("".to_owned());
diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
index 0558b76..83c3db6 100644
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@@ -141,9 +141,9 @@ fn simple_pattern_unparser(
         SimplePattern::Embedded { .. } => {
             match ctxt.m.mode {
                 ModuleContextMode::TargetIOValue =>
-                    item(seq!["preserves::value::Value::Domain(", src.as_ref().unwrap().to_owned(), ".as_preserves()).wrap()"]),
+                    item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".as_preserves()).wrap()"]),
                 ModuleContextMode::TargetAny =>
-                    item(seq!["preserves::value::Value::Domain(", src.as_ref().unwrap().to_owned(), ").wrap()"]),
+                    item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ").wrap()"]),
             }
         }
         SimplePattern::Lit { value } =>
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index cd33538..db2267c 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -2,7 +2,7 @@
 #![allow(unused_imports)]
 
 use std::convert::TryFrom;
-use preserves::value::Domain;
+use preserves::value::Embeddable;
 use preserves::value::NestedValue;
 use crate::support as _support;
 
diff --git a/implementations/rust/preserves/src/lib.rs b/implementations/rust/preserves/src/lib.rs
index 54c8ca1..6c1e3b3 100644
--- a/implementations/rust/preserves/src/lib.rs
+++ b/implementations/rust/preserves/src/lib.rs
@@ -11,7 +11,7 @@ pub mod value;
 #[cfg(test)]
 mod dom {
     use super::value::{
-        Value, IOValue, IOResult, NestedValue, PlainValue, PreDomain, Domain,
+        Value, IOValue, IOResult, NestedValue, PlainValue, Domain,
         PackedWriter,
     };
 
@@ -21,8 +21,7 @@ mod dom {
         Two,
     }
 
-    impl Domain for Dom {}
-    impl PreDomain for Dom {
+    impl Domain for Dom {
         fn from_preserves(v: IOValue) -> IOResult<Self> {
             panic!("Cannot decode IOValue to Dom: {:?}", v);
         }
@@ -37,7 +36,7 @@ mod dom {
 
     #[test] fn test_one() {
         let v: PlainValue<_> = Value::from(vec![Value::from(1).wrap(),
-                                                Value::Domain(Dom::One).wrap(),
+                                                Value::Embedded(Dom::One).wrap(),
                                                 Value::from(2).wrap()])
             .wrap();
         assert_eq!(PackedWriter::encode(&v.to_io_value()).unwrap(),
@@ -46,7 +45,7 @@ mod dom {
 
     #[test] fn test_two() {
         let v: PlainValue<_> = Value::from(vec![Value::from(1).wrap(),
-                                                Value::Domain(Dom::Two).wrap(),
+                                                Value::Embedded(Dom::Two).wrap(),
                                                 Value::from(2).wrap()])
             .wrap();
         assert_eq!(PackedWriter::encode(&v.to_io_value()).unwrap(),
diff --git a/implementations/rust/preserves/src/value/mod.rs b/implementations/rust/preserves/src/value/mod.rs
index 6c20177..f37f54c 100644
--- a/implementations/rust/preserves/src/value/mod.rs
+++ b/implementations/rust/preserves/src/value/mod.rs
@@ -17,12 +17,12 @@ pub use repr::AnnotatedValue;
 pub use repr::ArcValue;
 pub use repr::Domain;
 pub use repr::Double;
+pub use repr::Embeddable;
 pub use repr::Float;
 pub use repr::IOValue;
 pub use repr::Map;
 pub use repr::NestedValue;
 pub use repr::PlainValue;
-pub use repr::PreDomain;
 pub use repr::RcValue;
 pub use repr::Record;
 pub use repr::Set;
diff --git a/implementations/rust/preserves/src/value/packed/reader.rs b/implementations/rust/preserves/src/value/packed/reader.rs
index ef0c75f..af7f417 100644
--- a/implementations/rust/preserves/src/value/packed/reader.rs
+++ b/implementations/rust/preserves/src/value/packed/reader.rs
@@ -275,7 +275,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
             }
             Tag::Embedded => {
                 let v = self.demand_next(read_annotations)?;
-                Value::Domain(v).wrap()
+                Value::Embedded(v).wrap()
             }
             Tag::SmallInteger(v) => {
                 // TODO: prebuild these in value.rs
diff --git a/implementations/rust/preserves/src/value/repr.rs b/implementations/rust/preserves/src/value/repr.rs
index a470090..0382ef0 100644
--- a/implementations/rust/preserves/src/value/repr.rs
+++ b/implementations/rust/preserves/src/value/repr.rs
@@ -21,15 +21,15 @@ use super::IOResult;
 use super::signed_integer::SignedInteger;
 use crate::error::{Error, ExpectedKind, Received};
 
-pub trait PreDomain: Sized + Debug + Eq + Hash + Ord {
+pub trait Domain: Sized + Debug + Eq + Hash + Ord {
     fn from_preserves(v: IOValue) -> IOResult<Self>;
     fn as_preserves(&self) -> IOValue;
 }
 
-pub trait Domain: PreDomain + Clone {}
+pub trait Embeddable: Domain + Clone {}
+impl<T> Embeddable for T where T: Domain + Clone {}
 
-impl<D: PreDomain> Domain for Arc<D> {}
-impl<D: PreDomain> PreDomain for Arc<D> {
+impl<D: Domain> Domain for Arc<D> {
     fn from_preserves(v: IOValue) -> IOResult<Self> {
         Ok(Arc::new(D::from_preserves(v)?))
     }
@@ -39,7 +39,7 @@ impl<D: PreDomain> PreDomain for Arc<D> {
     }
 }
 
-pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
+pub trait NestedValue<D: Embeddable>: Sized + Debug + Clone + Eq + Hash + Ord {
     fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self;
 
     fn annotations(&self) -> &Annotations<Self, D>;
@@ -54,7 +54,7 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
         self.value().fmt(f)
     }
 
-    fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<M>
+    fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<M>
     where
         F: Fn(&D) -> IOResult<Value<M, E>>
     {
@@ -66,13 +66,13 @@ pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
     }
 
     fn from_io_value(v: &IOValue) -> IOResult<Self> {
-        v.copy_via(&|d| Ok(Value::Domain(D::from_preserves(d.clone())?)))
+        v.copy_via(&|d| Ok(Value::Embedded(D::from_preserves(d.clone())?)))
     }
 }
 
 /// The `Value`s from the specification.
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
+pub enum Value<N, D> where N: NestedValue<D>, D: Embeddable {
     Boolean(bool),
     Float(Float),
     Double(Double),
@@ -84,7 +84,7 @@ pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
     Sequence(Vec<N>),
     Set(Set<N>),
     Dictionary(Map<N, N>),
-    Domain(D),
+    Embedded(D),
 }
 
 /// Single-precision IEEE 754 Value
@@ -128,7 +128,7 @@ impl<N> Record<N> {
         &mut self.0
     }
 
-    pub fn finish<D: Domain>(self) -> Value<N, D> where N: NestedValue<D> {
+    pub fn finish<D: Embeddable>(self) -> Value<N, D> where N: NestedValue<D> {
         Value::Record(self)
     }
 }
@@ -217,38 +217,38 @@ impl PartialOrd for Double {
 
 impl Eq for Double {}
 
-impl<N: NestedValue<D>, D: Domain> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }
 
-impl<N: NestedValue<D>, D: Domain> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<&Float> for Value<N, D> { fn from(v: &Float) -> Self { Value::Float(v.clone()) } }
-impl<N: NestedValue<D>, D: Domain> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<&Double> for Value<N, D> { fn from(v: &Double) -> Self { Value::Double(v.clone()) } }
+impl<N: NestedValue<D>, D: Embeddable> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&Float> for Value<N, D> { fn from(v: &Float) -> Self { Value::Float(v.clone()) } }
+impl<N: NestedValue<D>, D: Embeddable> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&Double> for Value<N, D> { fn from(v: &Double) -> Self { Value::Double(v.clone()) } }
 
-impl<N: NestedValue<D>, D: Domain> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
-impl<N: NestedValue<D>, D: Domain> From<&SignedInteger> for Value<N, D> { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } }
+impl<N: NestedValue<D>, D: Embeddable> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&BigInt> for Value<N, D> { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&SignedInteger> for Value<N, D> { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } }
 
-impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
-impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
-impl<N: NestedValue<D>, D: Domain> From<&String> for Value<N, D> { fn from(v: &String) -> Self { Value::String(v.to_owned()) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
+impl<N: NestedValue<D>, D: Embeddable> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&String> for Value<N, D> { fn from(v: &String) -> Self { Value::String(v.to_owned()) } }
 
-impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
-// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
+// impl<N: NestedValue<D>, D: Embeddable> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }
 
-impl<N: NestedValue<D>, D: Domain> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
-impl<N: NestedValue<D>, D: Domain> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
-impl<N: NestedValue<D>, D: Domain> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
+impl<N: NestedValue<D>, D: Embeddable> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }
 
-impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Debug for Value<N, D> {
     // Not *quite* a formatter for the Preserves text syntax, since it
     // doesn't escape strings/symbols properly.
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -287,14 +287,14 @@ impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
                 f.debug_set().entries(v.iter()).finish()
             }
             Value::Dictionary(v) => f.debug_map().entries(v.iter()).finish(),
-            Value::Domain(d) => write!(f, "#!{:?}", d),
+            Value::Embedded(d) => write!(f, "#!{:?}", d),
         }
     }
 }
 
 //---------------------------------------------------------------------------
 
-impl<N: NestedValue<D>, D: Domain> Value<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Value<N, D> {
     pub fn wrap(self) -> N {
         N::wrap(Annotations::empty(), self)
     }
@@ -777,7 +777,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
     }
 
     pub fn as_embedded(&self) -> Option<&D> {
-        if let Value::Domain(d) = self {
+        if let Value::Embedded(d) = self {
             Some(d)
         } else {
             None
@@ -788,7 +788,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
         self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded))
     }
 
-    pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<Value<M, E>>
+    pub fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<Value<M, E>>
     where
         F: Fn(&D) -> IOResult<Value<M, E>>
     {
@@ -810,12 +810,12 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
             Value::Dictionary(v) =>
                 Value::Dictionary(v.iter().map(|(a,b)| Ok((a.copy_via(f)?, b.copy_via(f)?)))
                                   .collect::<IOResult<Map<_, _>>>()?),
-            Value::Domain(d) => f(d)?,
+            Value::Embedded(d) => f(d)?,
         })
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Index<usize> for Value<N, D> {
     type Output = N;
 
     fn index(&self, i: usize) -> &Self::Output {
@@ -823,13 +823,13 @@ impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> IndexMut<usize> for Value<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> IndexMut<usize> for Value<N, D> {
     fn index_mut(&mut self, i: usize) -> &mut Self::Output {
         &mut self.as_sequence_mut().unwrap()[i]
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Index<&N> for Value<N, D> {
     type Output = N;
 
     fn index(&self, i: &N) -> &Self::Output {
@@ -852,13 +852,13 @@ impl<'de> serde::Deserialize<'de> for UnwrappedIOValue {
     }
 }
 
-pub fn serialize_nested_value<S, N, D: Domain>(v: &N, serializer: S) ->
+pub fn serialize_nested_value<S, N, D: Embeddable>(v: &N, serializer: S) ->
     Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D> + serde::Serialize
 {
     super::magic::output_value(serializer, v.to_io_value())
 }
 
-pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
+pub fn deserialize_nested_value<'de, D, N, Dom: Embeddable>(deserializer: D) ->
     Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom> + serde::Deserialize<'de>
 {
     N::from_io_value(&super::magic::input_value(deserializer)?)
@@ -868,9 +868,9 @@ pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
 //---------------------------------------------------------------------------
 
 #[derive(Clone)]
-pub struct Annotations<N: NestedValue<D>, D: Domain>(Option<Vec<N>>, PhantomData<D>);
+pub struct Annotations<N: NestedValue<D>, D: Embeddable>(Option<Vec<N>>, PhantomData<D>);
 
-impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Annotations<N, D> {
     pub fn empty() -> Self {
         Annotations(None,
                     PhantomData)
@@ -901,7 +901,7 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
         self
     }
 
-    pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> IOResult<Annotations<M, E>>
+    pub fn copy_via<M: NestedValue<E>, E: Embeddable, F>(&self, f: &F) -> IOResult<Annotations<M, E>>
     where
         F: Fn(&D) -> IOResult<Value<M, E>>
     {
@@ -918,35 +918,35 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
 /// A possibly-annotated Value, with annotations (themselves
 /// possibly-annotated) in order of appearance.
 #[derive(Clone)]
-pub struct AnnotatedValue<N: NestedValue<D>, D: Domain>(pub Annotations<N, D>, pub Value<N, D>);
+pub struct AnnotatedValue<N: NestedValue<D>, D: Embeddable>(pub Annotations<N, D>, pub Value<N, D>);
 
-impl<N: NestedValue<D>, D: Domain> AnnotatedValue<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> AnnotatedValue<N, D> {
     fn new(anns: Annotations<N, D>, value: Value<N, D>) -> Self {
         AnnotatedValue(anns, value)
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> PartialEq for AnnotatedValue<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> PartialEq for AnnotatedValue<N, D> {
     fn eq(&self, other: &Self) -> bool {
         self.1.eq(&other.1)
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> Eq for AnnotatedValue<N, D> {}
+impl<N: NestedValue<D>, D: Embeddable> Eq for AnnotatedValue<N, D> {}
 
-impl<N: NestedValue<D>, D: Domain> Hash for AnnotatedValue<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Hash for AnnotatedValue<N, D> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.1.hash(state);
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> PartialOrd for AnnotatedValue<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> PartialOrd for AnnotatedValue<N, D> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
+impl<N: NestedValue<D>, D: Embeddable> Ord for AnnotatedValue<N, D> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.1.cmp(&other.1)
     }
@@ -955,9 +955,9 @@ impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
 //---------------------------------------------------------------------------
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct PlainValue<D: Domain>(AnnotatedValue<PlainValue<D>, D>);
+pub struct PlainValue<D: Embeddable>(AnnotatedValue<PlainValue<D>, D>);
 
-impl<D: Domain> PlainValue<D> {
+impl<D: Embeddable> PlainValue<D> {
     pub fn annotations_mut(&mut self) -> &mut Annotations<Self, D> {
         &mut (self.0).0
     }
@@ -967,7 +967,7 @@ impl<D: Domain> PlainValue<D> {
     }
 }
 
-impl<D: Domain> NestedValue<D> for PlainValue<D> {
+impl<D: Embeddable> NestedValue<D> for PlainValue<D> {
     fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
         PlainValue(AnnotatedValue::new(anns, v))
     }
@@ -990,19 +990,19 @@ impl<D: Domain> NestedValue<D> for PlainValue<D> {
     }
 }
 
-impl<D: Domain> Debug for PlainValue<D> {
+impl<D: Embeddable> Debug for PlainValue<D> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.debug_fmt(f)
     }
 }
 
-impl<D: Domain> serde::Serialize for PlainValue<D> {
+impl<D: Embeddable> serde::Serialize for PlainValue<D> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
         serialize_nested_value(self, serializer)
     }
 }
 
-impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
+impl<'de, Dom: Embeddable> serde::Deserialize<'de> for PlainValue<Dom> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
         deserialize_nested_value(deserializer)
     }
@@ -1013,9 +1013,9 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
 use std::rc::Rc;
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct RcValue<D: Domain>(Rc<AnnotatedValue<RcValue<D>, D>>);
+pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>, D>>);
 
-impl<D: Domain> NestedValue<D> for RcValue<D> {
+impl<D: Embeddable> NestedValue<D> for RcValue<D> {
     fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
         RcValue(Rc::new(AnnotatedValue::new(anns, v)))
     }
@@ -1040,19 +1040,19 @@ impl<D: Domain> NestedValue<D> for RcValue<D> {
     }
 }
 
-impl<D: Domain> Debug for RcValue<D> {
+impl<D: Embeddable> Debug for RcValue<D> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.debug_fmt(f)
     }
 }
 
-impl<D: Domain> serde::Serialize for RcValue<D> {
+impl<D: Embeddable> serde::Serialize for RcValue<D> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
         serialize_nested_value(self, serializer)
     }
 }
 
-impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
+impl<'de, Dom: Embeddable> serde::Deserialize<'de> for RcValue<Dom> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
         deserialize_nested_value(deserializer)
     }
@@ -1061,9 +1061,9 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
 //---------------------------------------------------------------------------
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ArcValue<D: Domain>(Arc<AnnotatedValue<ArcValue<D>, D>>);
+pub struct ArcValue<D: Embeddable>(Arc<AnnotatedValue<ArcValue<D>, D>>);
 
-impl<D: Domain> NestedValue<D> for ArcValue<D> {
+impl<D: Embeddable> NestedValue<D> for ArcValue<D> {
     fn wrap(anns: Annotations<Self, D>, v: Value<Self, D>) -> Self {
         ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
     }
@@ -1088,19 +1088,19 @@ impl<D: Domain> NestedValue<D> for ArcValue<D> {
     }
 }
 
-impl<D: Domain> Debug for ArcValue<D> {
+impl<D: Embeddable> Debug for ArcValue<D> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.debug_fmt(f)
     }
 }
 
-impl<D: Domain> serde::Serialize for ArcValue<D> {
+impl<D: Embeddable> serde::Serialize for ArcValue<D> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
         serialize_nested_value(self, serializer)
     }
 }
 
-impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
+impl<'de, Dom: Embeddable> serde::Deserialize<'de> for ArcValue<Dom> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
         deserialize_nested_value(deserializer)
     }
@@ -1112,8 +1112,7 @@ impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
 pub struct IOValue(Arc<AnnotatedValue<IOValue, IOValue>>);
 pub type UnwrappedIOValue = Value<IOValue, IOValue>;
 
-impl Domain for IOValue {}
-impl PreDomain for IOValue {
+impl Domain for IOValue {
     fn from_preserves(v: IOValue) -> IOResult<Self> {
         Ok(v)
     }
diff --git a/implementations/rust/preserves/src/value/writer.rs b/implementations/rust/preserves/src/value/writer.rs
index b6272a8..41421f5 100644
--- a/implementations/rust/preserves/src/value/writer.rs
+++ b/implementations/rust/preserves/src/value/writer.rs
@@ -132,7 +132,7 @@ pub trait Writer: Sized {
                 }
                 self.end_set(c)
             }
-            Value::Domain(d) => {
+            Value::Embedded(d) => {
                 let mut c = self.start_embedded()?;
                 c.write(&d)?;
                 self.end_embedded(c)