diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs
index a777683..761f4e8 100644
--- a/implementations/rust/preserves-schema/src/compiler/mod.rs
+++ b/implementations/rust/preserves-schema/src/compiler/mod.rs
@@ -56,7 +56,7 @@ impl CompilerConfig {
         for i in inputs {
             let mut f = File::open(&i)?;
             let mut reader = PackedReader::decode_read(&mut f);
-            let blob = _Any::from_io_value(&reader.demand_next(false)?)?;
+            let blob = reader.demand_next(false)?;
 
             if let Ok(s) = Schema::try_from(blob.clone()) {
                 let prefix = i.file_stem().ok_or_else(
@@ -126,7 +126,7 @@ pub fn compile(config: &CompilerConfig) -> Result<(), std::io::Error> {
         lines.push("lazy_static! {".to_owned());
         for (value, name) in m.literals {
             let bs = preserves::value::PackedWriter::encode(&value.to_io_value()).unwrap();
-            lines.push(format!("    pub static ref {}: _Any = /* {:?} */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec!{:?}).unwrap()).unwrap();",
+            lines.push(format!("    pub static ref {}: preserves::value::IOValue = /* {:?} */ preserves::value::packed::from_bytes(&vec!{:?}).unwrap();",
                                name,
                                value,
                                bs));
diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs
index f61fe89..4f05427 100644
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@@ -26,7 +26,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                                 let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body);
                                 let dest = dest.as_ref().map(String::as_str);
                                 construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
-                                item(seq!["fn ", fname.clone(), "(value: &_Any) -> ",
+                                item(seq!["fn ", fname.clone(), "(value: &preserves::value::IOValue) -> ",
                                           "std::result::Result<", names::render_constructor(n), ", ()> ",
                                           block(body)])
                             });
@@ -49,10 +49,10 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                 }
             }
 
-            item(seq!["impl std::convert::TryFrom", anglebrackets!["_Any"], " for ",
+            item(seq!["impl std::convert::TryFrom", anglebrackets!["preserves::value::IOValue"], " for ",
                       names::render_constructor(n), " ", block![
                           seq!["type Error = ();"],
-                          seq!["fn try_from(value: _Any) -> ",
+                          seq!["fn try_from(value: preserves::value::IOValue) -> ",
                                "std::result::Result<Self, Self::Error> ",
                                block(body)]]])
         });
@@ -95,6 +95,8 @@ fn store_wrap(is_struct: bool, ty: &TField, expr: &str) -> String {
     }
 }
 
+const MAP_ERR_Q: &str = ".map_err(|_| ())?";
+
 fn simple_pattern_parser(
     ctxt: &mut FunctionContext,
     p: &SimplePattern,
@@ -105,7 +107,7 @@ fn simple_pattern_parser(
     let dest = ctxt.gentempname();
     match p {
         SimplePattern::Any => {
-            push_let(body, item(dest.to_owned()), item(src.to_owned()));
+            push_let(body, item(dest.to_owned()), item(seq!["_Any::from_io_value", parens![src.to_owned()], MAP_ERR_Q]));
             dest
         },
         SimplePattern::Atom { atom_kind: k } => {
@@ -118,11 +120,11 @@ fn simple_pattern_parser(
                 AtomKind::ByteString => "to_bytestring",
                 AtomKind::Symbol => "to_symbol",
             };
-            push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().", converter, "().map_err(|_| ())?"]));
+            push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().", converter, "()", MAP_ERR_Q]));
             dest
         },
         SimplePattern::Embedded { .. } => {
-            push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().to_embedded().map_err(|_| ())?"]));
+            push_let(body, item(dest.to_owned()), item(seq![src.to_owned(), ".value().to_embedded()", MAP_ERR_Q]));
             dest
         },
         SimplePattern::Lit { value } => {
@@ -152,7 +154,7 @@ fn simple_pattern_parser(
                                  store_wrap(true, &field_type(pattern), &item_dest), ");"]));
             push_let_mut(body, item(dest.to_owned()), item("preserves::value::Set::new()"));
             body.push(item(seq!["for ", tmp.to_owned(),
-                                " in ", src.to_owned(), ".value().to_set().map_err(|_| ())?",
+                                " in ", src.to_owned(), ".value().to_set()", MAP_ERR_Q,
                                 " ", block(inner)]));
             dest
         },
@@ -168,7 +170,7 @@ fn simple_pattern_parser(
                 store_wrap(true, &field_type(value), &value_dest), ");"]));
             push_let_mut(body, item(dest.to_owned()), item("preserves::value::Map::new()"));
             body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
-                                " in ", src.to_owned(), ".value().to_dictionary().map_err(|_| ())?",
+                                " in ", src.to_owned(), ".value().to_dictionary()", MAP_ERR_Q,
                                 " ", block(inner)]));
             dest
         },
@@ -194,7 +196,7 @@ fn sequenceify(
             let tmp = ctxt.gentempname();
             push_let(body,
                      item(tmp.to_owned()),
-                     item(seq![src.to_owned(), ".value().to_sequence().map_err(|_| ())?"]));
+                     item(seq![src.to_owned(), ".value().to_sequence()", MAP_ERR_Q]));
             (tmp, 0)
         }
     }
@@ -250,7 +252,7 @@ fn pattern_parser(
             match &**c {
                 CompoundPattern::Rec { label, fields } => {
                     let rtmp = ctxt.gentempname();
-                    push_let(body, item(rtmp.to_owned()), item(seq![src.to_owned(), ".value().to_record(None).map_err(|_| ())?"]));
+                    push_let(body, item(rtmp.to_owned()), item(seq![src.to_owned(), ".value().to_record(None)", MAP_ERR_Q]));
                     named_pattern_parser(ctxt, &**label, &format!("{}.label()", rtmp), None, body);
                     named_pattern_parser(ctxt, &**fields, &format!("{}.fields()", rtmp), Some(0), body);
                 },
@@ -265,7 +267,7 @@ fn pattern_parser(
                 },
                 CompoundPattern::Dict { entries } => {
                     let dtmp = ctxt.gentempname();
-                    push_let(body, item(dtmp.to_owned()), item(seq![src.to_owned(), ".value().to_dictionary().map_err(|_| ())?"]));
+                    push_let(body, item(dtmp.to_owned()), item(seq![src.to_owned(), ".value().to_dictionary()", MAP_ERR_Q]));
                     for (key_lit, value_pat) in entries.0.iter() {
                         let vtmp = ctxt.gentempname();
                         push_let(body, item(vtmp.to_owned()), item(seq![
diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
index 278d6ba..78deade 100644
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@@ -82,7 +82,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
             }
 
             item(seq!["impl std::convert::From", anglebrackets![seq!["&", names::render_constructor(n)]],
-                      " for _Any ", block![
+                      " for preserves::value::IOValue ", block![
                           seq!["fn from(value: &", names::render_constructor(n), ") -> Self ",
                                block(body)]]])
         });
@@ -121,7 +121,7 @@ fn simple_pattern_unparser(
     let src = &vc.src;
     match p {
         SimplePattern::Any =>
-            item(seq![src.as_ref().unwrap().to_owned(), ".clone()"]),
+            item(seq![src.as_ref().unwrap().to_owned(), ".to_io_value()"]),
         SimplePattern::Atom { atom_kind: k } => {
             match &**k {
                 AtomKind::Symbol =>
@@ -166,7 +166,7 @@ fn simple_pattern_unparser(
                       ").collect()).wrap()"])
         }
         SimplePattern::Ref(_r) =>
-            item(seq!["_Any::from(", src.as_ref().unwrap().to_owned(),
+            item(seq!["preserves::value::IOValue::from(", src.as_ref().unwrap().to_owned(),
                       if vc.is_struct { "" } else { ".as_ref()" },
                       ")"]),
     }
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index c41ae09..973be38 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -5,35 +5,35 @@ use preserves::value::NestedValue;
 use crate::support::*;
 
 lazy_static! {
-    pub static ref LIT15: _Any = /* #f */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![128]).unwrap()).unwrap();
-    pub static ref LIT28: _Any = /* 1 */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![145]).unwrap()).unwrap();
-    pub static ref LIT0: _Any = /* Boolean */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap()).unwrap();
-    pub static ref LIT5: _Any = /* ByteString */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap()).unwrap();
-    pub static ref LIT2: _Any = /* Double */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap()).unwrap();
-    pub static ref LIT1: _Any = /* Float */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap()).unwrap();
-    pub static ref LIT3: _Any = /* SignedInteger */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap()).unwrap();
-    pub static ref LIT4: _Any = /* String */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap()).unwrap();
-    pub static ref LIT6: _Any = /* Symbol */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap()).unwrap();
-    pub static ref LIT14: _Any = /* and */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap()).unwrap();
-    pub static ref LIT21: _Any = /* any */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap()).unwrap();
-    pub static ref LIT22: _Any = /* atom */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap()).unwrap();
-    pub static ref LIT8: _Any = /* bundle */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap()).unwrap();
-    pub static ref LIT18: _Any = /* definitions */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap()).unwrap();
-    pub static ref LIT12: _Any = /* dict */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap()).unwrap();
-    pub static ref LIT27: _Any = /* dictof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap()).unwrap();
-    pub static ref LIT23: _Any = /* embedded */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap()).unwrap();
-    pub static ref LIT19: _Any = /* embeddedType */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap()).unwrap();
-    pub static ref LIT24: _Any = /* lit */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap()).unwrap();
-    pub static ref LIT7: _Any = /* named */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap()).unwrap();
-    pub static ref LIT13: _Any = /* or */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap()).unwrap();
-    pub static ref LIT9: _Any = /* rec */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap()).unwrap();
-    pub static ref LIT16: _Any = /* ref */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap()).unwrap();
-    pub static ref LIT17: _Any = /* schema */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap()).unwrap();
-    pub static ref LIT25: _Any = /* seqof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap()).unwrap();
-    pub static ref LIT26: _Any = /* setof */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap()).unwrap();
-    pub static ref LIT10: _Any = /* tuple */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap()).unwrap();
-    pub static ref LIT11: _Any = /* tuplePrefix */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap()).unwrap();
-    pub static ref LIT20: _Any = /* version */ _Any::from_io_value(&preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap()).unwrap();
+    pub static ref LIT15: preserves::value::IOValue = /* #f */ preserves::value::packed::from_bytes(&vec![128]).unwrap();
+    pub static ref LIT28: preserves::value::IOValue = /* 1 */ preserves::value::packed::from_bytes(&vec![145]).unwrap();
+    pub static ref LIT0: preserves::value::IOValue = /* Boolean */ preserves::value::packed::from_bytes(&vec![179, 7, 66, 111, 111, 108, 101, 97, 110]).unwrap();
+    pub static ref LIT5: preserves::value::IOValue = /* ByteString */ preserves::value::packed::from_bytes(&vec![179, 10, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103]).unwrap();
+    pub static ref LIT2: preserves::value::IOValue = /* Double */ preserves::value::packed::from_bytes(&vec![179, 6, 68, 111, 117, 98, 108, 101]).unwrap();
+    pub static ref LIT1: preserves::value::IOValue = /* Float */ preserves::value::packed::from_bytes(&vec![179, 5, 70, 108, 111, 97, 116]).unwrap();
+    pub static ref LIT3: preserves::value::IOValue = /* SignedInteger */ preserves::value::packed::from_bytes(&vec![179, 13, 83, 105, 103, 110, 101, 100, 73, 110, 116, 101, 103, 101, 114]).unwrap();
+    pub static ref LIT4: preserves::value::IOValue = /* String */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 116, 114, 105, 110, 103]).unwrap();
+    pub static ref LIT6: preserves::value::IOValue = /* Symbol */ preserves::value::packed::from_bytes(&vec![179, 6, 83, 121, 109, 98, 111, 108]).unwrap();
+    pub static ref LIT14: preserves::value::IOValue = /* and */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 100]).unwrap();
+    pub static ref LIT21: preserves::value::IOValue = /* any */ preserves::value::packed::from_bytes(&vec![179, 3, 97, 110, 121]).unwrap();
+    pub static ref LIT22: preserves::value::IOValue = /* atom */ preserves::value::packed::from_bytes(&vec![179, 4, 97, 116, 111, 109]).unwrap();
+    pub static ref LIT8: preserves::value::IOValue = /* bundle */ preserves::value::packed::from_bytes(&vec![179, 6, 98, 117, 110, 100, 108, 101]).unwrap();
+    pub static ref LIT18: preserves::value::IOValue = /* definitions */ preserves::value::packed::from_bytes(&vec![179, 11, 100, 101, 102, 105, 110, 105, 116, 105, 111, 110, 115]).unwrap();
+    pub static ref LIT12: preserves::value::IOValue = /* dict */ preserves::value::packed::from_bytes(&vec![179, 4, 100, 105, 99, 116]).unwrap();
+    pub static ref LIT27: preserves::value::IOValue = /* dictof */ preserves::value::packed::from_bytes(&vec![179, 6, 100, 105, 99, 116, 111, 102]).unwrap();
+    pub static ref LIT23: preserves::value::IOValue = /* embedded */ preserves::value::packed::from_bytes(&vec![179, 8, 101, 109, 98, 101, 100, 100, 101, 100]).unwrap();
+    pub static ref LIT19: preserves::value::IOValue = /* embeddedType */ preserves::value::packed::from_bytes(&vec![179, 12, 101, 109, 98, 101, 100, 100, 101, 100, 84, 121, 112, 101]).unwrap();
+    pub static ref LIT24: preserves::value::IOValue = /* lit */ preserves::value::packed::from_bytes(&vec![179, 3, 108, 105, 116]).unwrap();
+    pub static ref LIT7: preserves::value::IOValue = /* named */ preserves::value::packed::from_bytes(&vec![179, 5, 110, 97, 109, 101, 100]).unwrap();
+    pub static ref LIT13: preserves::value::IOValue = /* or */ preserves::value::packed::from_bytes(&vec![179, 2, 111, 114]).unwrap();
+    pub static ref LIT9: preserves::value::IOValue = /* rec */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 99]).unwrap();
+    pub static ref LIT16: preserves::value::IOValue = /* ref */ preserves::value::packed::from_bytes(&vec![179, 3, 114, 101, 102]).unwrap();
+    pub static ref LIT17: preserves::value::IOValue = /* schema */ preserves::value::packed::from_bytes(&vec![179, 6, 115, 99, 104, 101, 109, 97]).unwrap();
+    pub static ref LIT25: preserves::value::IOValue = /* seqof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 113, 111, 102]).unwrap();
+    pub static ref LIT26: preserves::value::IOValue = /* setof */ preserves::value::packed::from_bytes(&vec![179, 5, 115, 101, 116, 111, 102]).unwrap();
+    pub static ref LIT10: preserves::value::IOValue = /* tuple */ preserves::value::packed::from_bytes(&vec![179, 5, 116, 117, 112, 108, 101]).unwrap();
+    pub static ref LIT11: preserves::value::IOValue = /* tuplePrefix */ preserves::value::packed::from_bytes(&vec![179, 11, 116, 117, 112, 108, 101, 80, 114, 101, 102, 105, 120]).unwrap();
+    pub static ref LIT20: preserves::value::IOValue = /* version */ preserves::value::packed::from_bytes(&vec![179, 7, 118, 101, 114, 115, 105, 111, 110]).unwrap();
 }
 
 pub type _Ptr = preserves::value::IOValue;
@@ -130,31 +130,31 @@ pub enum SimplePattern {
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
 pub struct Version;
 
-fn _parse_atom_kind_boolean(value: &_Any) -> std::result::Result<AtomKind, ()> {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)}
+fn _parse_atom_kind_boolean(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {if value != &*LIT0 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Boolean)}
 
-fn _parse_atom_kind_float(value: &_Any) -> std::result::Result<AtomKind, ()> {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)}
+fn _parse_atom_kind_float(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {if value != &*LIT1 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Float)}
 
-fn _parse_atom_kind_double(value: &_Any) -> std::result::Result<AtomKind, ()> {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)}
+fn _parse_atom_kind_double(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {if value != &*LIT2 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Double)}
 
-fn _parse_atom_kind_signed_integer(value: &_Any) -> std::result::Result<AtomKind, ()> {
+fn _parse_atom_kind_signed_integer(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {
     if value != &*LIT3 { return Err(()); }
     let _tmp0 = ();
     Ok(AtomKind::SignedInteger)
 }
 
-fn _parse_atom_kind_string(value: &_Any) -> std::result::Result<AtomKind, ()> {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)}
+fn _parse_atom_kind_string(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {if value != &*LIT4 { return Err(()); } let _tmp0 = (); Ok(AtomKind::String)}
 
-fn _parse_atom_kind_byte_string(value: &_Any) -> std::result::Result<AtomKind, ()> {
+fn _parse_atom_kind_byte_string(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {
     if value != &*LIT5 { return Err(()); }
     let _tmp0 = ();
     Ok(AtomKind::ByteString)
 }
 
-fn _parse_atom_kind_symbol(value: &_Any) -> std::result::Result<AtomKind, ()> {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)}
+fn _parse_atom_kind_symbol(value: &preserves::value::IOValue) -> std::result::Result<AtomKind, ()> {if value != &*LIT6 { return Err(()); } let _tmp0 = (); Ok(AtomKind::Symbol)}
 
-impl std::convert::TryFrom<_Any> for AtomKind {
+impl std::convert::TryFrom<preserves::value::IOValue> for AtomKind {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_atom_kind_boolean(value) { return Ok(r); }
         if let Ok(r) = _parse_atom_kind_float(value) { return Ok(r); }
@@ -167,7 +167,7 @@ impl std::convert::TryFrom<_Any> for AtomKind {
     }
 }
 
-impl std::convert::From<&AtomKind> for _Any {
+impl std::convert::From<&AtomKind> for preserves::value::IOValue {
     fn from(value: &AtomKind) -> Self {
         match value {
             AtomKind::Boolean => (&*LIT0).clone(),
@@ -181,9 +181,9 @@ impl std::convert::From<&AtomKind> for _Any {
     }
 }
 
-impl std::convert::TryFrom<_Any> for Binding {
+impl std::convert::TryFrom<preserves::value::IOValue> for Binding {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
         if _tmp0.label() != &*LIT7 { return Err(()); }
@@ -195,21 +195,21 @@ impl std::convert::TryFrom<_Any> for Binding {
     }
 }
 
-impl std::convert::From<&Binding> for _Any {
+impl std::convert::From<&Binding> for preserves::value::IOValue {
     fn from(value: &Binding) -> Self {
         let Binding {name: _tmp0, pattern: _tmp1} = value;
         {
             let mut _tmp2 = preserves::value::Record(vec![(&*LIT7).clone()]);
             _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap());
-            _tmp2.fields_vec_mut().push(_Any::from(_tmp1));
+            _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1));
             _tmp2.finish().wrap()
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for Bundle {
+impl std::convert::TryFrom<preserves::value::IOValue> for Bundle {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
         if _tmp0.label() != &*LIT8 { return Err(()); }
@@ -220,18 +220,18 @@ impl std::convert::TryFrom<_Any> for Bundle {
     }
 }
 
-impl std::convert::From<&Bundle> for _Any {
+impl std::convert::From<&Bundle> for preserves::value::IOValue {
     fn from(value: &Bundle) -> Self {
         let Bundle {modules: _tmp0} = value;
         {
             let mut _tmp1 = preserves::value::Record(vec![(&*LIT8).clone()]);
-            _tmp1.fields_vec_mut().push(_Any::from(_tmp0));
+            _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0));
             _tmp1.finish().wrap()
         }
     }
 }
 
-fn _parse_compound_pattern_rec(value: &_Any) -> std::result::Result<CompoundPattern, ()> {
+fn _parse_compound_pattern_rec(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT9 { return Err(()); }
     let _tmp1 = ();
@@ -241,7 +241,7 @@ fn _parse_compound_pattern_rec(value: &_Any) -> std::result::Result<CompoundPatt
     Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
 }
 
-fn _parse_compound_pattern_tuple(value: &_Any) -> std::result::Result<CompoundPattern, ()> {
+fn _parse_compound_pattern_tuple(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT10 { return Err(()); }
     let _tmp1 = ();
@@ -252,7 +252,7 @@ fn _parse_compound_pattern_tuple(value: &_Any) -> std::result::Result<CompoundPa
     Ok(CompoundPattern::Tuple {patterns: _tmp2})
 }
 
-fn _parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result<CompoundPattern, ()> {
+fn _parse_compound_pattern_tuple_prefix(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT11 { return Err(()); }
     let _tmp1 = ();
@@ -264,7 +264,7 @@ fn _parse_compound_pattern_tuple_prefix(value: &_Any) -> std::result::Result<Com
     Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
 }
 
-fn _parse_compound_pattern_dict(value: &_Any) -> std::result::Result<CompoundPattern, ()> {
+fn _parse_compound_pattern_dict(value: &preserves::value::IOValue) -> std::result::Result<CompoundPattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT12 { return Err(()); }
     let _tmp1 = ();
@@ -273,9 +273,9 @@ fn _parse_compound_pattern_dict(value: &_Any) -> std::result::Result<CompoundPat
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl std::convert::TryFrom<_Any> for CompoundPattern {
+impl std::convert::TryFrom<preserves::value::IOValue> for CompoundPattern {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_compound_pattern_rec(value) { return Ok(r); }
         if let Ok(r) = _parse_compound_pattern_tuple(value) { return Ok(r); }
@@ -285,13 +285,13 @@ impl std::convert::TryFrom<_Any> for CompoundPattern {
     }
 }
 
-impl std::convert::From<&CompoundPattern> for _Any {
+impl std::convert::From<&CompoundPattern> for preserves::value::IOValue {
     fn from(value: &CompoundPattern) -> Self {
         match value {
             CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
                 let mut _tmp2 = preserves::value::Record(vec![(&*LIT9).clone()]);
-                _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
-                _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref()));
+                _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
+                _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
                 _tmp2.finish().wrap()
             },
             CompoundPattern::Tuple {patterns: _tmp0} => {
@@ -299,7 +299,7 @@ impl std::convert::From<&CompoundPattern> for _Any {
                 _tmp1.fields_vec_mut().push(
                     {
                         let mut _tmp2 = vec![];
-                        for _tmp3 in _tmp0 {_tmp2.push(_Any::from(_tmp3));}
+                        for _tmp3 in _tmp0 {_tmp2.push(preserves::value::IOValue::from(_tmp3));}
                         preserves::value::Value::Sequence(_tmp2).wrap()
                     }
                 );
@@ -310,23 +310,23 @@ impl std::convert::From<&CompoundPattern> for _Any {
                 _tmp2.fields_vec_mut().push(
                     {
                         let mut _tmp3 = vec![];
-                        for _tmp4 in _tmp0 {_tmp3.push(_Any::from(_tmp4));}
+                        for _tmp4 in _tmp0 {_tmp3.push(preserves::value::IOValue::from(_tmp4));}
                         preserves::value::Value::Sequence(_tmp3).wrap()
                     }
                 );
-                _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref()));
+                _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
                 _tmp2.finish().wrap()
             },
             CompoundPattern::Dict {entries: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT12).clone()]);
-                _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
+                _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
                 _tmp1.finish().wrap()
             },
         }
     }
 }
 
-fn _parse_definition_or(value: &_Any) -> std::result::Result<Definition, ()> {
+fn _parse_definition_or(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT13 { return Err(()); }
     let _tmp1 = ();
@@ -344,7 +344,7 @@ fn _parse_definition_or(value: &_Any) -> std::result::Result<Definition, ()> {
     })
 }
 
-fn _parse_definition_and(value: &_Any) -> std::result::Result<Definition, ()> {
+fn _parse_definition_and(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT14 { return Err(()); }
     let _tmp1 = ();
@@ -362,14 +362,14 @@ fn _parse_definition_and(value: &_Any) -> std::result::Result<Definition, ()> {
     })
 }
 
-fn _parse_definition_pattern(value: &_Any) -> std::result::Result<Definition, ()> {
+fn _parse_definition_pattern(value: &preserves::value::IOValue) -> std::result::Result<Definition, ()> {
     let _tmp0 = Pattern::try_from(value.clone())?;
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl std::convert::TryFrom<_Any> for Definition {
+impl std::convert::TryFrom<preserves::value::IOValue> for Definition {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_definition_or(value) { return Ok(r); }
         if let Ok(r) = _parse_definition_and(value) { return Ok(r); }
@@ -378,7 +378,7 @@ impl std::convert::TryFrom<_Any> for Definition {
     }
 }
 
-impl std::convert::From<&Definition> for _Any {
+impl std::convert::From<&Definition> for preserves::value::IOValue {
     fn from(value: &Definition) -> Self {
         match value {
             Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
@@ -386,9 +386,9 @@ impl std::convert::From<&Definition> for _Any {
                 _tmp3.fields_vec_mut().push(
                     {
                         let mut _tmp4 = vec![];
-                        _tmp4.push(_Any::from(_tmp0.as_ref()));
-                        _tmp4.push(_Any::from(_tmp1.as_ref()));
-                        for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));}
+                        _tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref()));
+                        _tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref()));
+                        for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));}
                         preserves::value::Value::Sequence(_tmp4).wrap()
                     }
                 );
@@ -399,22 +399,22 @@ impl std::convert::From<&Definition> for _Any {
                 _tmp3.fields_vec_mut().push(
                     {
                         let mut _tmp4 = vec![];
-                        _tmp4.push(_Any::from(_tmp0.as_ref()));
-                        _tmp4.push(_Any::from(_tmp1.as_ref()));
-                        for _tmp5 in _tmp2 {_tmp4.push(_Any::from(_tmp5));}
+                        _tmp4.push(preserves::value::IOValue::from(_tmp0.as_ref()));
+                        _tmp4.push(preserves::value::IOValue::from(_tmp1.as_ref()));
+                        for _tmp5 in _tmp2 {_tmp4.push(preserves::value::IOValue::from(_tmp5));}
                         preserves::value::Value::Sequence(_tmp4).wrap()
                     }
                 );
                 _tmp3.finish().wrap()
             },
-            Definition::Pattern(_tmp0) => _Any::from(_tmp0.as_ref()),
+            Definition::Pattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for Definitions {
+impl std::convert::TryFrom<preserves::value::IOValue> for Definitions {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? {
@@ -426,20 +426,23 @@ impl std::convert::TryFrom<_Any> for Definitions {
     }
 }
 
-impl std::convert::From<&Definitions> for _Any {
+impl std::convert::From<&Definitions> for preserves::value::IOValue {
     fn from(value: &Definitions) -> Self {
         let Definitions(_tmp0) = value;
-        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _Any::from(_tmp2))).collect()).wrap()
+        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (
+            preserves::value::Value::symbol(_tmp1).wrap(),
+            preserves::value::IOValue::from(_tmp2)
+        )).collect()).wrap()
     }
 }
 
-impl std::convert::TryFrom<_Any> for DictionaryEntries {
+impl std::convert::TryFrom<preserves::value::IOValue> for DictionaryEntries {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? {
-            let _tmp3 = _tmp1;
+            let _tmp3 = _Any::from_io_value(_tmp1).map_err(|_| ())?;
             let _tmp4 = NamedSimplePattern::try_from(_tmp2.clone())?;
             _tmp0.insert(_tmp3.clone(), _tmp4);
         }
@@ -447,27 +450,27 @@ impl std::convert::TryFrom<_Any> for DictionaryEntries {
     }
 }
 
-impl std::convert::From<&DictionaryEntries> for _Any {
+impl std::convert::From<&DictionaryEntries> for preserves::value::IOValue {
     fn from(value: &DictionaryEntries) -> Self {
         let DictionaryEntries(_tmp0) = value;
-        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _Any::from(_tmp2))).collect()).wrap()
+        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.to_io_value(), preserves::value::IOValue::from(_tmp2))).collect()).wrap()
     }
 }
 
-fn _parse_embedded_type_name_ref(value: &_Any) -> std::result::Result<EmbeddedTypeName, ()> {
+fn _parse_embedded_type_name_ref(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, ()> {
     let _tmp0 = Ref::try_from(value.clone())?;
     Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-fn _parse_embedded_type_name_false(value: &_Any) -> std::result::Result<EmbeddedTypeName, ()> {
+fn _parse_embedded_type_name_false(value: &preserves::value::IOValue) -> std::result::Result<EmbeddedTypeName, ()> {
     if value != &*LIT15 { return Err(()); }
     let _tmp0 = ();
     Ok(EmbeddedTypeName::False)
 }
 
-impl std::convert::TryFrom<_Any> for EmbeddedTypeName {
+impl std::convert::TryFrom<preserves::value::IOValue> for EmbeddedTypeName {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_embedded_type_name_ref(value) { return Ok(r); }
         if let Ok(r) = _parse_embedded_type_name_false(value) { return Ok(r); }
@@ -475,18 +478,18 @@ impl std::convert::TryFrom<_Any> for EmbeddedTypeName {
     }
 }
 
-impl std::convert::From<&EmbeddedTypeName> for _Any {
+impl std::convert::From<&EmbeddedTypeName> for preserves::value::IOValue {
     fn from(value: &EmbeddedTypeName) -> Self {
         match value {
-            EmbeddedTypeName::Ref(_tmp0) => _Any::from(_tmp0.as_ref()),
+            EmbeddedTypeName::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
             EmbeddedTypeName::False => (&*LIT15).clone(),
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for ModulePath {
+impl std::convert::TryFrom<preserves::value::IOValue> for ModulePath {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp1 = value.value().to_sequence().map_err(|_| ())?;
         let mut _tmp0 = std::vec::Vec::new();
@@ -498,7 +501,7 @@ impl std::convert::TryFrom<_Any> for ModulePath {
     }
 }
 
-impl std::convert::From<&ModulePath> for _Any {
+impl std::convert::From<&ModulePath> for preserves::value::IOValue {
     fn from(value: &ModulePath) -> Self {
         let ModulePath(_tmp0) = value;
         {
@@ -509,9 +512,9 @@ impl std::convert::From<&ModulePath> for _Any {
     }
 }
 
-impl std::convert::TryFrom<_Any> for Modules {
+impl std::convert::TryFrom<preserves::value::IOValue> for Modules {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary().map_err(|_| ())? {
@@ -523,16 +526,16 @@ impl std::convert::TryFrom<_Any> for Modules {
     }
 }
 
-impl std::convert::From<&Modules> for _Any {
+impl std::convert::From<&Modules> for preserves::value::IOValue {
     fn from(value: &Modules) -> Self {
         let Modules(_tmp0) = value;
-        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_Any::from(_tmp1), _Any::from(_tmp2))).collect()).wrap()
+        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::IOValue::from(_tmp1), preserves::value::IOValue::from(_tmp2))).collect()).wrap()
     }
 }
 
-impl std::convert::TryFrom<_Any> for NamedAlternative {
+impl std::convert::TryFrom<preserves::value::IOValue> for NamedAlternative {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp0 = value.value().to_sequence().map_err(|_| ())?;
         if _tmp0.len() - 0 < 2 { return Err(()); }
@@ -542,31 +545,31 @@ impl std::convert::TryFrom<_Any> for NamedAlternative {
     }
 }
 
-impl std::convert::From<&NamedAlternative> for _Any {
+impl std::convert::From<&NamedAlternative> for preserves::value::IOValue {
     fn from(value: &NamedAlternative) -> Self {
         let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = value;
         {
             let mut _tmp2 = vec![];
             _tmp2.push(preserves::value::Value::from(_tmp0).wrap());
-            _tmp2.push(_Any::from(_tmp1));
+            _tmp2.push(preserves::value::IOValue::from(_tmp1));
             preserves::value::Value::Sequence(_tmp2).wrap()
         }
     }
 }
 
-fn _parse_named_pattern_named(value: &_Any) -> std::result::Result<NamedPattern, ()> {
+fn _parse_named_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, ()> {
     let _tmp0 = Binding::try_from(value.clone())?;
     Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn _parse_named_pattern_anonymous(value: &_Any) -> std::result::Result<NamedPattern, ()> {
+fn _parse_named_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result<NamedPattern, ()> {
     let _tmp0 = Pattern::try_from(value.clone())?;
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl std::convert::TryFrom<_Any> for NamedPattern {
+impl std::convert::TryFrom<preserves::value::IOValue> for NamedPattern {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_named_pattern_named(value) { return Ok(r); }
         if let Ok(r) = _parse_named_pattern_anonymous(value) { return Ok(r); }
@@ -574,28 +577,28 @@ impl std::convert::TryFrom<_Any> for NamedPattern {
     }
 }
 
-impl std::convert::From<&NamedPattern> for _Any {
+impl std::convert::From<&NamedPattern> for preserves::value::IOValue {
     fn from(value: &NamedPattern) -> Self {
         match value {
-            NamedPattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()),
-            NamedPattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()),
+            NamedPattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
+            NamedPattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
         }
     }
 }
 
-fn _parse_named_simple_pattern_named(value: &_Any) -> std::result::Result<NamedSimplePattern, ()> {
+fn _parse_named_simple_pattern_named(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, ()> {
     let _tmp0 = Binding::try_from(value.clone())?;
     Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn _parse_named_simple_pattern_anonymous(value: &_Any) -> std::result::Result<NamedSimplePattern, ()> {
+fn _parse_named_simple_pattern_anonymous(value: &preserves::value::IOValue) -> std::result::Result<NamedSimplePattern, ()> {
     let _tmp0 = SimplePattern::try_from(value.clone())?;
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl std::convert::TryFrom<_Any> for NamedSimplePattern {
+impl std::convert::TryFrom<preserves::value::IOValue> for NamedSimplePattern {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_named_simple_pattern_named(value) { return Ok(r); }
         if let Ok(r) = _parse_named_simple_pattern_anonymous(value) { return Ok(r); }
@@ -603,28 +606,28 @@ impl std::convert::TryFrom<_Any> for NamedSimplePattern {
     }
 }
 
-impl std::convert::From<&NamedSimplePattern> for _Any {
+impl std::convert::From<&NamedSimplePattern> for preserves::value::IOValue {
     fn from(value: &NamedSimplePattern) -> Self {
         match value {
-            NamedSimplePattern::Named(_tmp0) => _Any::from(_tmp0.as_ref()),
-            NamedSimplePattern::Anonymous(_tmp0) => _Any::from(_tmp0.as_ref()),
+            NamedSimplePattern::Named(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
+            NamedSimplePattern::Anonymous(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
         }
     }
 }
 
-fn _parse_pattern_simple_pattern(value: &_Any) -> std::result::Result<Pattern, ()> {
+fn _parse_pattern_simple_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, ()> {
     let _tmp0 = SimplePattern::try_from(value.clone())?;
     Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
 }
 
-fn _parse_pattern_compound_pattern(value: &_Any) -> std::result::Result<Pattern, ()> {
+fn _parse_pattern_compound_pattern(value: &preserves::value::IOValue) -> std::result::Result<Pattern, ()> {
     let _tmp0 = CompoundPattern::try_from(value.clone())?;
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl std::convert::TryFrom<_Any> for Pattern {
+impl std::convert::TryFrom<preserves::value::IOValue> for Pattern {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_pattern_simple_pattern(value) { return Ok(r); }
         if let Ok(r) = _parse_pattern_compound_pattern(value) { return Ok(r); }
@@ -632,18 +635,18 @@ impl std::convert::TryFrom<_Any> for Pattern {
     }
 }
 
-impl std::convert::From<&Pattern> for _Any {
+impl std::convert::From<&Pattern> for preserves::value::IOValue {
     fn from(value: &Pattern) -> Self {
         match value {
-            Pattern::SimplePattern(_tmp0) => _Any::from(_tmp0.as_ref()),
-            Pattern::CompoundPattern(_tmp0) => _Any::from(_tmp0.as_ref()),
+            Pattern::SimplePattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
+            Pattern::CompoundPattern(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for Ref {
+impl std::convert::TryFrom<preserves::value::IOValue> for Ref {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
         if _tmp0.label() != &*LIT16 { return Err(()); }
@@ -655,21 +658,21 @@ impl std::convert::TryFrom<_Any> for Ref {
     }
 }
 
-impl std::convert::From<&Ref> for _Any {
+impl std::convert::From<&Ref> for preserves::value::IOValue {
     fn from(value: &Ref) -> Self {
         let Ref {module: _tmp0, name: _tmp1} = value;
         {
             let mut _tmp2 = preserves::value::Record(vec![(&*LIT16).clone()]);
-            _tmp2.fields_vec_mut().push(_Any::from(_tmp0));
+            _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0));
             _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap());
             _tmp2.finish().wrap()
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for Schema {
+impl std::convert::TryFrom<preserves::value::IOValue> for Schema {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
         if _tmp0.label() != &*LIT17 { return Err(()); }
@@ -686,7 +689,7 @@ impl std::convert::TryFrom<_Any> for Schema {
     }
 }
 
-impl std::convert::From<&Schema> for _Any {
+impl std::convert::From<&Schema> for preserves::value::IOValue {
     fn from(value: &Schema) -> Self {
         let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = value;
         {
@@ -694,9 +697,9 @@ impl std::convert::From<&Schema> for _Any {
             _tmp3.fields_vec_mut().push(
                 {
                     let mut _tmp4 = preserves::value::Map::new();
-                    _tmp4.insert((&*LIT18).clone(), _Any::from(_tmp0));
-                    _tmp4.insert((&*LIT19).clone(), _Any::from(_tmp1));
-                    _tmp4.insert((&*LIT20).clone(), _Any::from(_tmp2));
+                    _tmp4.insert((&*LIT18).clone(), preserves::value::IOValue::from(_tmp0));
+                    _tmp4.insert((&*LIT19).clone(), preserves::value::IOValue::from(_tmp1));
+                    _tmp4.insert((&*LIT20).clone(), preserves::value::IOValue::from(_tmp2));
                     preserves::value::Value::Dictionary(_tmp4).wrap()
                 }
             );
@@ -705,9 +708,9 @@ impl std::convert::From<&Schema> for _Any {
     }
 }
 
-fn _parse_simple_pattern_any(value: &_Any) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
+fn _parse_simple_pattern_any(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {if value != &*LIT21 { return Err(()); } let _tmp0 = (); Ok(SimplePattern::Any)}
 
-fn _parse_simple_pattern_atom(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_atom(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT22 { return Err(()); }
     let _tmp1 = ();
@@ -716,7 +719,7 @@ fn _parse_simple_pattern_atom(value: &_Any) -> std::result::Result<SimplePattern
     Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
 }
 
-fn _parse_simple_pattern_embedded(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_embedded(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT23 { return Err(()); }
     let _tmp1 = ();
@@ -725,16 +728,16 @@ fn _parse_simple_pattern_embedded(value: &_Any) -> std::result::Result<SimplePat
     Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
 }
 
-fn _parse_simple_pattern_lit(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_lit(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT24 { return Err(()); }
     let _tmp1 = ();
     if _tmp0.fields().len() - 0 < 1 { return Err(()); }
-    let _tmp2 = (&_tmp0.fields()[0]);
+    let _tmp2 = _Any::from_io_value((&_tmp0.fields()[0])).map_err(|_| ())?;
     Ok(SimplePattern::Lit {value: _tmp2.clone()})
 }
 
-fn _parse_simple_pattern_seqof(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_seqof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT25 { return Err(()); }
     let _tmp1 = ();
@@ -743,7 +746,7 @@ fn _parse_simple_pattern_seqof(value: &_Any) -> std::result::Result<SimplePatter
     Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn _parse_simple_pattern_setof(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_setof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT26 { return Err(()); }
     let _tmp1 = ();
@@ -752,7 +755,7 @@ fn _parse_simple_pattern_setof(value: &_Any) -> std::result::Result<SimplePatter
     Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn _parse_simple_pattern_dictof(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_dictof(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = value.value().to_record(None).map_err(|_| ())?;
     if _tmp0.label() != &*LIT27 { return Err(()); }
     let _tmp1 = ();
@@ -762,14 +765,14 @@ fn _parse_simple_pattern_dictof(value: &_Any) -> std::result::Result<SimplePatte
     Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
 }
 
-fn _parse_simple_pattern_ref(value: &_Any) -> std::result::Result<SimplePattern, ()> {
+fn _parse_simple_pattern_ref(value: &preserves::value::IOValue) -> std::result::Result<SimplePattern, ()> {
     let _tmp0 = Ref::try_from(value.clone())?;
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl std::convert::TryFrom<_Any> for SimplePattern {
+impl std::convert::TryFrom<preserves::value::IOValue> for SimplePattern {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if let Ok(r) = _parse_simple_pattern_any(value) { return Ok(r); }
         if let Ok(r) = _parse_simple_pattern_atom(value) { return Ok(r); }
@@ -783,49 +786,49 @@ impl std::convert::TryFrom<_Any> for SimplePattern {
     }
 }
 
-impl std::convert::From<&SimplePattern> for _Any {
+impl std::convert::From<&SimplePattern> for preserves::value::IOValue {
     fn from(value: &SimplePattern) -> Self {
         match value {
             SimplePattern::Any => (&*LIT21).clone(),
             SimplePattern::Atom {atom_kind: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT22).clone()]);
-                _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
+                _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Embedded {interface: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT23).clone()]);
-                _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
+                _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Lit {value: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT24).clone()]);
-                _tmp1.fields_vec_mut().push(_tmp0.clone());
+                _tmp1.fields_vec_mut().push(_tmp0.to_io_value());
                 _tmp1.finish().wrap()
             },
             SimplePattern::Seqof {pattern: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT25).clone()]);
-                _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
+                _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Setof {pattern: _tmp0} => {
                 let mut _tmp1 = preserves::value::Record(vec![(&*LIT26).clone()]);
-                _tmp1.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
+                _tmp1.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Dictof {key: _tmp0, value: _tmp1} => {
                 let mut _tmp2 = preserves::value::Record(vec![(&*LIT27).clone()]);
-                _tmp2.fields_vec_mut().push(_Any::from(_tmp0.as_ref()));
-                _tmp2.fields_vec_mut().push(_Any::from(_tmp1.as_ref()));
+                _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp0.as_ref()));
+                _tmp2.fields_vec_mut().push(preserves::value::IOValue::from(_tmp1.as_ref()));
                 _tmp2.finish().wrap()
             },
-            SimplePattern::Ref(_tmp0) => _Any::from(_tmp0.as_ref()),
+            SimplePattern::Ref(_tmp0) => preserves::value::IOValue::from(_tmp0.as_ref()),
         }
     }
 }
 
-impl std::convert::TryFrom<_Any> for Version {
+impl std::convert::TryFrom<preserves::value::IOValue> for Version {
     type Error = ();
-    fn try_from(value: _Any) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: preserves::value::IOValue) -> std::result::Result<Self, Self::Error> {
         let value = &value;
         if value != &*LIT28 { return Err(()); }
         let _tmp0 = ();
@@ -833,5 +836,5 @@ impl std::convert::TryFrom<_Any> for Version {
     }
 }
 
-impl std::convert::From<&Version> for _Any {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}}
+impl std::convert::From<&Version> for preserves::value::IOValue {fn from(value: &Version) -> Self {let Version = value; (&*LIT28).clone()}}
 
diff --git a/implementations/rust/preserves-schema/src/lib.rs b/implementations/rust/preserves-schema/src/lib.rs
index 27ef55f..c0c09e8 100644
--- a/implementations/rust/preserves-schema/src/lib.rs
+++ b/implementations/rust/preserves-schema/src/lib.rs
@@ -31,16 +31,16 @@ mod tests {
 
     #[test]
     fn metaschema_parsing() -> Result<(), std::io::Error> {
-        use preserves::value::{Reader, NestedValue};
+        use preserves::value::{Reader, IOValue};
         use std::convert::TryFrom;
         use std::convert::From;
         use crate::gen::schema::*;
 
         let mut f = std::fs::File::open("../../../schema/schema.bin")?;
         let mut reader = preserves::value::PackedReader::decode_read(&mut f);
-        let schema = _Any::from_io_value(&reader.demand_next(false)?)?;
+        let schema = reader.demand_next(false)?;
         let parsed = Schema::try_from(schema.clone()).expect("successful parse");
-        assert_eq!(schema, _Any::from(&parsed));
+        assert_eq!(schema, IOValue::from(&parsed));
         Ok(())
     }
 }