diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs
index 97337c7..896569b 100644
--- a/implementations/rust/preserves-schema/src/compiler/context.rs
+++ b/implementations/rust/preserves-schema/src/compiler/context.rs
@@ -58,6 +58,11 @@ pub enum CaptureMode {
     Indefinite(Vec<Item>),
 }
 
+pub enum RefRenderStyle {
+    Bare,
+    Qualified,
+}
+
 lazy_static! {
     static ref ID_RE: regex::Regex = regex::Regex::new(r"^[a-zA-Z][a-zA-Z_0-9]*$").unwrap();
 }
@@ -74,7 +79,14 @@ impl<'b> BundleContext<'b> {
     }
 
     pub fn type_for_name(&self, r: &Ref) -> Option<&types::TDefinition> {
-        self.types.get(r)
+        if r.module.0.is_empty() {
+            panic!("BundleContext::type_for_name with module-relative ref {:?}", r);
+        }
+        let result = self.types.get(r);
+        if result.is_none() && !self.config.module_aliases.contains_key(&r.module.0) {
+            panic!("Attempted to lookup unknown type {:?}", r)
+        }
+        result
     }
 
     pub fn define_literal(&mut self, v: &IOValue) -> String {
@@ -138,7 +150,7 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
         self.functiondefs.push(i)
     }
 
-    pub fn render_ref(&self, r: &Ref, with_generic_args: bool) -> Item {
+    pub fn render_ref(&self, r: &Ref, style: RefRenderStyle) -> Item {
         let base = match self.bundle.config.module_aliases.get(&r.module.0) {
             None =>
                 if r.module.0.is_empty() {
@@ -153,43 +165,32 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
             Some(s) =>
                 item(name![s.to_owned(), r.name.to_owned()])
         };
-        if with_generic_args && self.ref_has_embedded(r) {
-            item(seq![base, anglebrackets!["_Any"]])
-        } else {
-            base
+        let q = self.ref_has_embedded(r);
+        match style {
+            RefRenderStyle::Bare =>
+                base,
+            RefRenderStyle::Qualified =>
+                if q { item(seq![base, anglebrackets!["_Value"]]) } else { base },
         }
     }
 
     pub fn any_type(&self) -> &'static str {
-        "_Any"
-    }
-
-    pub fn qualify(&self, r: &Ref) -> Ref {
-        if r.module.0.is_empty() {
-            Ref { module: self.module_path.clone(), name: r.name.clone() }
-        } else {
-            r.clone()
-        }
-    }
-
-    pub fn type_for_name(&self, r: &Ref) -> Option<&types::TDefinition> {
-        self.bundle.type_for_name(&self.qualify(r))
+        "_Value"
     }
 
     pub fn ref_has_embedded(&self, r: &Ref) -> bool {
-        match self.type_for_name(r) {
-            Some(ty) => ty.has_embedded(self),
-            None => false, // TODO: should this be configurable?
-        }
+        let r = r.qualify(&self.module_path);
+        self.bundle.type_for_name(&r).map(|ty| ty.has_embedded(self.bundle)).unwrap_or(false)
+        // ^ TODO: should the "false" be configurable?
     }
 
     pub fn literals_generic_decls(&self) -> Item {
-        item(anglebrackets!["_Any: preserves::value::NestedValue"])
+        item(anglebrackets!["_Value: preserves::value::NestedValue"])
     }
 
     pub fn literals_generic_decls_with_defaults(&self) -> Item {
         item(anglebrackets![
-            seq!["_Any: preserves::value::NestedValue = ",
+            seq!["_Value: preserves::value::NestedValue = ",
                  if self.schema.embedded_type == EmbeddedTypeName::False {
                      "preserves::value::IOValue"
                  } else {
@@ -198,11 +199,11 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
     }
 
     pub fn literals_generic_arg(&self) -> Item {
-        item("<_Any>")
+        item("<_Value>")
     }
 
     pub fn literals_type(&self) -> Item {
-        item(seq!["&", self.literals_base_type(), self.literals_generic_arg()])
+        item(seq![self.literals_base_type(), self.literals_generic_arg()])
     }
 
     pub fn literals_base_type(&self) -> Item {
diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs
index 730ca1a..b4e7c29 100644
--- a/implementations/rust/preserves-schema/src/compiler/mod.rs
+++ b/implementations/rust/preserves-schema/src/compiler/mod.rs
@@ -6,8 +6,10 @@ pub mod types;
 pub mod unparsers;
 
 use crate::*;
+use crate::support::Parse;
 use crate::compiler::context::*;
 use crate::gen::Literals;
+use crate::gen::schema;
 use crate::gen::schema::*;
 use crate::syntax::block::{Formatter, Item};
 use crate::syntax::block::constructors::*;
@@ -101,11 +103,13 @@ impl CompilerConfig {
     }
 
     fn build_type_cache(&self) -> Map<Ref, types::TDefinition> {
-        self.bundle.iter().flat_map(
-            |(modpath, s)| s.definitions.0.iter().map(
-                move |(name, def)| (Ref { module: ModulePath(modpath.clone()), name: name.clone() },
-                                    types::definition_type(def))))
-            .collect()
+        self.bundle.iter().flat_map(|(modpath, s)| {
+            let modpath = ModulePath(modpath.clone());
+            s.definitions.0.iter().map(move |(name, def)| {
+                let ty = types::definition_type(&modpath, name, def);
+                (ty.self_ref.clone(), ty)
+            })
+        }).collect()
     }
 
     fn generate_definition(
@@ -150,6 +154,16 @@ fn write_if_changed(output_path: &PathBuf, contents: &[u8]) -> io::Result<()> {
     f.write_all(contents)
 }
 
+impl Ref {
+    pub fn qualify(&self, default_module_path: &schema::ModulePath) -> Ref {
+        if self.module.0.is_empty() {
+            Ref { module: default_module_path.clone(), name: self.name.clone() }
+        } else {
+            self.clone()
+        }
+    }
+}
+
 impl Schema {
     pub fn has_embedded_type(&self) -> bool {
         self.embedded_type != EmbeddedTypeName::False
@@ -194,6 +208,8 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> {
             "use std::convert::TryFrom;",
             format!("use {}::support as _support;", &config.support_crate),
             "use _support::Deserialize;",
+            "use _support::Parse;",
+            "use _support::Unparse;",
             "use _support::preserves;",
             "use preserves::value::Domain;",
             "use preserves::value::NestedValue;",
diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs
index b48708d..40f0d7a 100644
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@@ -3,7 +3,10 @@ use crate::gen::schema::*;
 use crate::syntax::block::Item;
 use crate::syntax::block::constructors::*;
 
-use super::context::{ModuleContextMode, ModuleContext, FunctionContext};
+use super::context::FunctionContext;
+use super::context::ModuleContext;
+use super::context::ModuleContextMode;
+use super::context::RefRenderStyle;
 use super::names;
 use super::types::*;
 
@@ -19,7 +22,7 @@ impl compiler::Plugin for ParserPlugin {
 }
 
 pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
-    let ty = definition_type(d);
+    let ty = definition_type(&m.module_path, n, d);
 
     m.define_function(
         n,
@@ -41,7 +44,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                                 let dest = dest.as_ref().map(String::as_str);
                                 construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
                                 item(seq!["fn ", fname.clone(), ctxt.m.literals_generic_decls(),
-                                          "(_ctxt: ", ctxt.m.literals_type(), ", value: &", ctxt.m.any_type(), ") -> ",
+                                          "(_ctxt: &", ctxt.m.literals_type(), ", value: &", ctxt.m.any_type(), ") -> ",
                                           "std::result::Result<",
                                           names::render_constructor(n), ty.generic_arg(ctxt.m),
                                           ", _support::ParseError> ",
@@ -66,36 +69,16 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                 }
             }
 
-            let (topdecl, innerdecl) = if ty.has_embedded(ctxt.m) {
-                (ctxt.m.literals_generic_decls(), item(""))
-            } else {
-                (item(""), ctxt.m.literals_generic_decls())
-            };
-
-            item(seq!["impl", topdecl, " ",
+            item(seq!["impl", ctxt.m.literals_generic_decls(),
+                      " _support::Parse", anglebrackets![ctxt.m.literals_type(),
+                                                         ctxt.m.any_type()], " for ",
                       names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
                       block![
-                          seq!["pub fn parse", innerdecl, "(_ctxt: ", ctxt.m.literals_type(),
+                          seq!["fn parse(_ctxt: &", ctxt.m.literals_type(),
                                ", value: &", ctxt.m.any_type(), ") -> ",
                                "std::result::Result<Self, _support::ParseError> ",
                                codeblock(body)]]])
         });
-
-    // m.define_function(
-    //     n,
-    //     |ctxt| {
-    //         item(seq!["impl", ctxt.m.literals_generic_decls(),
-    //                   " std::convert::TryFrom", anglebrackets![seq!["&", ctxt.m.any_type()]], " for ",
-    //                   names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
-    //                   block![
-    //                       seq!["type Error = _support::ParseError;"],
-    //                       seq!["fn try_from(value: &", ctxt.m.any_type(), ") -> ",
-    //                            "std::result::Result<Self, _support::ParseError> ",
-    //                            codeblock![
-    //                                seq!["Self::parse(",
-    //                                     ctxt.m.literals_base_type(), "::default()",
-    //                                     ", value)"]]]]])
-    //     });
 }
 
 fn construct(
@@ -214,7 +197,7 @@ fn simple_pattern_parser(
             dest
         },
         SimplePattern::Ref(r) => {
-            let tf = name![ctxt.m.render_ref(&**r, false), "parse"];
+            let tf = name![ctxt.m.render_ref(&**r, RefRenderStyle::Bare), "parse"];
             ctxt.define_atom(body,
                              &dest,
                              item(seq![tf, parens!["_ctxt", src.to_owned()], "?"]));
diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs
index 83d565a..90cb7c2 100644
--- a/implementations/rust/preserves-schema/src/compiler/readers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/readers.rs
@@ -11,7 +11,10 @@ use preserves::value::IOValue;
 use preserves::value::NestedValue;
 use preserves::value::ValueClass;
 
-use super::context::{ModuleContextMode, ModuleContext, FunctionContext};
+use super::context::FunctionContext;
+use super::context::ModuleContext;
+use super::context::ModuleContextMode;
+use super::context::RefRenderStyle;
 use super::names;
 use super::types::*;
 
@@ -75,7 +78,7 @@ impl BoundaryTracker {
 }
 
 pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
-    let ty = definition_type(d);
+    let ty = definition_type(&m.module_path, n, d);
 
     m.define_function(
         n,
@@ -100,8 +103,8 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
                                 item(seq![
                                     "fn ", fname.clone(), anglebrackets![
                                         "'de",
-                                        "_Any: preserves::value::NestedValue",
-                                        "R: _support::Reader<'de, _Any>"],
+                                        "_Value: preserves::value::NestedValue",
+                                        "R: _support::Reader<'de, _Value>"],
                                     "(r: &mut R) -> ",
                                     "std::result::Result<",
                                     names::render_constructor(n), ty.generic_arg(ctxt.m),
@@ -139,9 +142,9 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
 
             item(seq![
                 "impl", anglebrackets!["'de",
-                                       "_Any: preserves::value::NestedValue",
-                                       "R: _support::Reader<'de, _Any>"], " ",
-                "_support::Deserialize", anglebrackets!["'de", "_Any", "R"], " ",
+                                       "_Value: preserves::value::NestedValue",
+                                       "R: _support::Reader<'de, _Value>"], " ",
+                "_support::Deserialize", anglebrackets!["'de", "_Value", "R"], " ",
                 "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", block![
                     seq!["fn deserialize(r: &mut R) -> ",
                          "std::result::Result<Self, _support::ParseError> ",
@@ -426,7 +429,7 @@ fn simple_pattern_reader(
             dest
         },
         SimplePattern::Ref(r) => {
-            let tf = name![ctxt.m.render_ref(&**r, false), "deserialize"];
+            let tf = name![ctxt.m.render_ref(&**r, RefRenderStyle::Bare), "deserialize"];
             ctxt.define_atom(body, &dest, item(seq![tf, "(r)?"]));
             dest
         },
diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs
index ce4f70b..0f40afe 100644
--- a/implementations/rust/preserves-schema/src/compiler/types.rs
+++ b/implementations/rust/preserves-schema/src/compiler/types.rs
@@ -5,13 +5,22 @@ use crate::gen::schema::*;
 
 use preserves::value::Set;
 
-use super::context::{ModuleContextMode, ModuleContext};
+use super::context::BundleContext;
+use super::context::ModuleContext;
+use super::context::ModuleContextMode;
+use super::context::RefRenderStyle;
 use super::names;
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
-pub enum TDefinition {
-    Union(Vec<(String, TSimple)>),
-    Simple(TSimple),
+pub struct TDefinition {
+    pub self_ref: Ref,
+    pub body: TDefinitionBody,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub enum TDefinitionBody {
+        Union(Vec<(String, TSimple)>),
+        Simple(TSimple),
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
@@ -42,7 +51,7 @@ impl compiler::Plugin for TypePlugin {
     fn generate_module(&self, m: &mut ModuleContext) {
         if let EmbeddedTypeName::Ref(r) = &m.schema.embedded_type {
             m.define_type(item(vertical(false, seq![
-                seq!["pub type _Dom = ", m.render_ref(&*r, true), ";"],
+                seq!["pub type _Dom = ", m.render_ref(&*r, RefRenderStyle::Bare), ";"],
                 seq!["pub type _Ptr = std::sync::Arc<_Dom>;"],
                 seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"]
             ])));
@@ -51,7 +60,7 @@ impl compiler::Plugin for TypePlugin {
 
     fn generate_definition(&self, m: &mut ModuleContext, n: &str, d: &Definition) {
         if let ModuleContextMode::TargetGeneric = m.mode {
-            let ty = definition_type(d);
+            let ty = definition_type(&m.module_path, n, d);
             m.define_type(item(ty.render(m, n)));
             m.define_type(item(seq![
                 "impl", ty.generic_decl(m), " preserves::value::Domain for ",
@@ -60,14 +69,17 @@ impl compiler::Plugin for TypePlugin {
     }
 }
 
-pub fn definition_type(d: &Definition) -> TDefinition {
-    match d {
-        Definition::Or { pattern_0, pattern_1, pattern_n } =>
-            TDefinition::Union(or_definition_type(pattern_0, pattern_1, pattern_n)),
-        Definition::And { pattern_0, pattern_1, pattern_n } =>
-            TDefinition::Simple(and_definition_type(pattern_0, pattern_1, pattern_n)),
-        Definition::Pattern(p) =>
-            TDefinition::Simple(pattern_type(p)),
+pub fn definition_type(module: &ModulePath, n: &str, d: &Definition) -> TDefinition {
+    TDefinition {
+        self_ref: Ref { module: module.clone(), name: n.to_owned() },
+        body: match d {
+            Definition::Or { pattern_0, pattern_1, pattern_n } =>
+                TDefinitionBody::Union(or_definition_type(pattern_0, pattern_1, pattern_n)),
+            Definition::And { pattern_0, pattern_1, pattern_n } =>
+                TDefinitionBody::Simple(and_definition_type(pattern_0, pattern_1, pattern_n)),
+            Definition::Pattern(p) =>
+                TDefinitionBody::Simple(pattern_type(p)),
+        }
     }
 }
 
@@ -183,8 +195,8 @@ impl TField {
     fn render(&self, ctxt: &ModuleContext, box_needed: bool) -> impl Emittable {
         match self {
             TField::Unit => seq!["()"],
-            TField::Any => seq!["_Any"],
-            TField::Embedded => seq!["_Ptr"],
+            TField::Any => seq!["_Value"],
+            TField::Embedded => seq!["_Value::D"],
             TField::Array(t) => seq!["std::vec::Vec<", t.render(ctxt, false), ">"],
             TField::Set(t) => seq!["preserves::value::Set<", t.render(ctxt, false), ">"],
             TField::Map(k, v) => seq!["preserves::value::Map",
@@ -192,29 +204,34 @@ impl TField {
                                                      v.render(ctxt, false)]],
             TField::Ref(r) =>
                 if box_needed {
-                    seq!["std::boxed::Box", anglebrackets![ctxt.render_ref(r, true)]]
+                    seq!["std::boxed::Box", anglebrackets![
+                        ctxt.render_ref(r, RefRenderStyle::Qualified)]]
                 } else {
-                    seq![ctxt.render_ref(r, true)]
+                    seq![ctxt.render_ref(r, RefRenderStyle::Qualified)]
                 },
             TField::Base(n) => seq![n.to_owned()],
         }
     }
 
-    pub fn has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set<Ref>) -> bool {
+    pub fn has_embedded(&self, default_module_path: &ModulePath, ctxt: &BundleContext, seen: &mut Set<Ref>) -> bool {
         match self {
             TField::Unit => false,
             TField::Any => true, // at least potentially true
             TField::Embedded => true,
-            TField::Array(f) => f.has_embedded(ctxt, seen),
-            TField::Set(f) => f.has_embedded(ctxt, seen),
-            TField::Map(k, v) => k.has_embedded(ctxt, seen) || v.has_embedded(ctxt, seen),
+            TField::Array(f) => f.has_embedded(default_module_path, ctxt, seen),
+            TField::Set(f) => f.has_embedded(default_module_path, ctxt, seen),
+            TField::Map(k, v) =>
+                k.has_embedded(default_module_path, ctxt, seen) ||
+                v.has_embedded(default_module_path, ctxt, seen),
             TField::Ref(r) => {
-                let r = ctxt.qualify(r);
+                let r = r.qualify(default_module_path);
                 if seen.contains(&r) {
                     false
                 } else {
                     seen.insert(r.clone());
                     ctxt.type_for_name(&r).map(|ty| ty._has_embedded(ctxt, seen)).unwrap_or(false)
+                    // ^ TODO: should the "false" be configurable?
+                    // cf. ModuleContext::ref_has_embedded.
                 }
             }
             TField::Base(_) => false,
@@ -237,17 +254,19 @@ impl TSimple {
              }]
     }
 
-    pub fn has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set<Ref>) -> bool {
+    pub fn has_embedded(&self, default_module_path: &ModulePath, ctxt: &BundleContext, seen: &mut Set<Ref>) -> bool {
         match self {
-            TSimple::Field(f) => f.has_embedded(ctxt, seen),
-            TSimple::Record(TRecord(fs)) => fs.iter().any(|(_k, v)| v.has_embedded(ctxt, seen)),
+            TSimple::Field(f) =>
+                f.has_embedded(default_module_path, ctxt, seen),
+            TSimple::Record(TRecord(fs)) =>
+                fs.iter().any(|(_k, v)| v.has_embedded(default_module_path, ctxt, seen)),
         }
     }
 }
 
 impl TDefinition {
     pub fn generic_decl(&self, ctxt: &ModuleContext) -> Item {
-        if self.has_embedded(ctxt) {
+        if self.has_embedded(ctxt.bundle) {
             ctxt.literals_generic_decls()
         } else {
             item("")
@@ -255,7 +274,7 @@ impl TDefinition {
     }
 
     pub fn generic_decl_with_defaults(&self, ctxt: &ModuleContext) -> Item {
-        if self.has_embedded(ctxt) {
+        if self.has_embedded(ctxt.bundle) {
             ctxt.literals_generic_decls_with_defaults()
         } else {
             item("")
@@ -263,7 +282,7 @@ impl TDefinition {
     }
 
     pub fn generic_arg(&self, ctxt: &ModuleContext) -> Item {
-        if self.has_embedded(ctxt) {
+        if self.has_embedded(ctxt.bundle) {
             ctxt.literals_generic_arg()
         } else {
             item("")
@@ -273,25 +292,27 @@ impl TDefinition {
     pub fn render(&self, ctxt: &ModuleContext, n: &str) -> impl Emittable {
         vertical(false, seq![
             "#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]",
-            match self {
-                TDefinition::Union(items) =>
+            match &self.body {
+                TDefinitionBody::Union(items) =>
                     seq!["pub enum ",
                          names::render_constructor(n), self.generic_decl_with_defaults(ctxt), " ",
                          vertical(false, braces(items.iter().map(
                              |(n, d)| item(d.render(ctxt, item(""), false, n))).collect()))],
-                TDefinition::Simple(s) =>
+                TDefinitionBody::Simple(s) =>
                     seq!["pub struct ", s.render(ctxt, self.generic_decl_with_defaults(ctxt), true, n)],
             }])
     }
 
-    pub fn has_embedded(&self, ctxt: &ModuleContext) -> bool {
+    pub fn has_embedded(&self, ctxt: &BundleContext) -> bool {
         self._has_embedded(ctxt, &mut Set::new())
     }
 
-    fn _has_embedded(&self, ctxt: &ModuleContext, seen: &mut Set<Ref>) -> bool {
-        match self {
-            TDefinition::Union(entries) => entries.iter().any(|(_k, v)| v.has_embedded(ctxt, seen)),
-            TDefinition::Simple(t) => t.has_embedded(ctxt, seen),
+    fn _has_embedded(&self, ctxt: &BundleContext, seen: &mut Set<Ref>) -> bool {
+        match &self.body {
+            TDefinitionBody::Union(entries) =>
+                entries.iter().any(|(_k, v)| v.has_embedded(&self.self_ref.module, ctxt, seen)),
+            TDefinitionBody::Simple(t) =>
+                t.has_embedded(&self.self_ref.module, ctxt, seen),
         }
     }
 }
diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
index a765f92..dd81496 100644
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@@ -61,7 +61,7 @@ fn normal_src(src: String, is_struct: bool) -> ValueContext {
 }
 
 pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
-    let ty = definition_type(d);
+    let ty = definition_type(&m.module_path, n, d);
 
     m.define_function(
         n,
@@ -97,17 +97,14 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
                 }
             }
 
-            let (topdecl, innerdecl) = if ty.has_embedded(ctxt.m) {
-                (ctxt.m.literals_generic_decls(), item(""))
-            } else {
-                (item(""), ctxt.m.literals_generic_decls())
-            };
-
-            item(seq!["impl", topdecl, " ",
-                      names::render_constructor(n), ty.generic_arg(ctxt.m), " ", block![
-                          seq!["pub fn unparse", innerdecl,
-                               "(&self, _ctxt: ", ctxt.m.literals_type(), ") -> ",
-                               ctxt.m.any_type(), " ", block(body)]]])
+            item(seq!["impl", ctxt.m.literals_generic_decls(),
+                      " _support::Unparse", anglebrackets![ctxt.m.literals_type(),
+                                                           ctxt.m.any_type()], " for ",
+                      names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
+                      block![
+                          seq!["fn unparse(&self, _ctxt: &", ctxt.m.literals_type(),
+                               ") -> ", ctxt.m.any_type(), " ",
+                               block(body)]]])
         });
 
     // m.define_function(
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index efda883..85f6b38 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -4,6 +4,8 @@
 use std::convert::TryFrom;
 use crate::support as _support;
 use _support::Deserialize;
+use _support::Parse;
+use _support::Unparse;
 use _support::preserves;
 use preserves::value::Domain;
 use preserves::value::NestedValue;
@@ -21,7 +23,7 @@ pub enum AtomKind {
 
 impl preserves::value::Domain for AtomKind {}
 
-fn read_atom_kind_boolean<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_boolean<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "Boolean" => {}
@@ -33,7 +35,7 @@ fn read_atom_kind_boolean<'de, _Any: preserves::value::NestedValue, R: _support:
     Ok(AtomKind::Boolean)
 }
 
-fn read_atom_kind_float<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_float<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "Float" => {}
@@ -45,7 +47,7 @@ fn read_atom_kind_float<'de, _Any: preserves::value::NestedValue, R: _support::R
     Ok(AtomKind::Float)
 }
 
-fn read_atom_kind_double<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_double<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "Double" => {}
@@ -57,7 +59,7 @@ fn read_atom_kind_double<'de, _Any: preserves::value::NestedValue, R: _support::
     Ok(AtomKind::Double)
 }
 
-fn read_atom_kind_signed_integer<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_signed_integer<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
@@ -69,7 +71,7 @@ fn read_atom_kind_signed_integer<'de, _Any: preserves::value::NestedValue, R: _s
     Ok(AtomKind::SignedInteger)
 }
 
-fn read_atom_kind_string<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_string<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "String" => {}
@@ -81,7 +83,7 @@ fn read_atom_kind_string<'de, _Any: preserves::value::NestedValue, R: _support::
     Ok(AtomKind::String)
 }
 
-fn read_atom_kind_byte_string<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_byte_string<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "ByteString" => {}
@@ -93,7 +95,7 @@ fn read_atom_kind_byte_string<'de, _Any: preserves::value::NestedValue, R: _supp
     Ok(AtomKind::ByteString)
 }
 
-fn read_atom_kind_symbol<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_symbol<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "Symbol" => {}
@@ -105,7 +107,7 @@ fn read_atom_kind_symbol<'de, _Any: preserves::value::NestedValue, R: _support::
     Ok(AtomKind::Symbol)
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for AtomKind {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for AtomKind {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -119,50 +121,50 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_atom_kind_boolean<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_boolean<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); }
     let _tmp0 = ();
     Ok(AtomKind::Boolean)
 }
 
-fn parse_atom_kind_float<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_float<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); }
     let _tmp0 = ();
     Ok(AtomKind::Float)
 }
 
-fn parse_atom_kind_double<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_double<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); }
     let _tmp0 = ();
     Ok(AtomKind::Double)
 }
 
-fn parse_atom_kind_signed_integer<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_signed_integer<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); }
     let _tmp0 = ();
     Ok(AtomKind::SignedInteger)
 }
 
-fn parse_atom_kind_string<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_string<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); }
     let _tmp0 = ();
     Ok(AtomKind::String)
 }
 
-fn parse_atom_kind_byte_string<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_byte_string<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); }
     let _tmp0 = ();
     Ok(AtomKind::ByteString)
 }
 
-fn parse_atom_kind_symbol<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_symbol<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
     if value != &_ctxt.LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); }
     let _tmp0 = ();
     Ok(AtomKind::Symbol)
 }
 
-impl AtomKind {
-    pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for AtomKind {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_atom_kind_boolean(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_atom_kind_float(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_atom_kind_double(_ctxt, value) { return Ok(r); }
@@ -174,8 +176,8 @@ impl AtomKind {
     }
 }
 
-impl AtomKind {
-    pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for AtomKind {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             AtomKind::Boolean => (&_ctxt.LIT_0_BOOLEAN).clone(),
             AtomKind::Float => (&_ctxt.LIT_1_FLOAT).clone(),
@@ -189,14 +191,14 @@ impl AtomKind {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Binding<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct Binding<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
     pub name: std::string::String,
-    pub pattern: SimplePattern<_Any>
+    pub pattern: SimplePattern<_Value>
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Binding<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Binding<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Binding<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Binding<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_record(None)?;
         let mut _tmp0 = _support::B::Type::default();
@@ -221,8 +223,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Binding<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Binding<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp0 = value.value().to_record(None)?;
         if _tmp0.label() != &_ctxt.LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); }
         let _tmp1 = ();
@@ -233,8 +235,8 @@ impl<_Any: preserves::value::NestedValue> Binding<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Binding<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Binding<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Binding {name: _tmp0, pattern: _tmp1} = self;
         {
             let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_7_NAMED).clone()]);
@@ -246,13 +248,13 @@ impl<_Any: preserves::value::NestedValue> Binding<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Bundle<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
-    pub modules: Modules<_Any>
+pub struct Bundle<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+    pub modules: Modules<_Value>
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Bundle<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Bundle<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Bundle<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Bundle<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_record(None)?;
         let mut _tmp0 = _support::B::Type::default();
@@ -274,8 +276,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Bundle<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Bundle<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp0 = value.value().to_record(None)?;
         if _tmp0.label() != &_ctxt.LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); }
         let _tmp1 = ();
@@ -285,8 +287,8 @@ impl<_Any: preserves::value::NestedValue> Bundle<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Bundle<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Bundle<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Bundle {modules: _tmp0} = self;
         {
             let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_8_BUNDLE).clone()]);
@@ -297,26 +299,26 @@ impl<_Any: preserves::value::NestedValue> Bundle<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum CompoundPattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum CompoundPattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
     Rec {
-        label: std::boxed::Box<NamedPattern<_Any>>,
-        fields: std::boxed::Box<NamedPattern<_Any>>
+        label: std::boxed::Box<NamedPattern<_Value>>,
+        fields: std::boxed::Box<NamedPattern<_Value>>
     },
     Tuple {
-        patterns: std::vec::Vec<NamedPattern<_Any>>
+        patterns: std::vec::Vec<NamedPattern<_Value>>
     },
     TuplePrefix {
-        fixed: std::vec::Vec<NamedPattern<_Any>>,
-        variable: std::boxed::Box<NamedSimplePattern<_Any>>
+        fixed: std::vec::Vec<NamedPattern<_Value>>,
+        variable: std::boxed::Box<NamedSimplePattern<_Value>>
     },
     Dict {
-        entries: std::boxed::Box<DictionaryEntries<_Any>>
+        entries: std::boxed::Box<DictionaryEntries<_Value>>
     }
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for CompoundPattern<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for CompoundPattern<_Value> {}
 
-fn read_compound_pattern_rec<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn read_compound_pattern_rec<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -339,7 +341,7 @@ fn read_compound_pattern_rec<'de, _Any: preserves::value::NestedValue, R: _suppo
     Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
 }
 
-fn read_compound_pattern_tuple<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn read_compound_pattern_tuple<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -368,7 +370,7 @@ fn read_compound_pattern_tuple<'de, _Any: preserves::value::NestedValue, R: _sup
     Ok(CompoundPattern::Tuple {patterns: _tmp2})
 }
 
-fn read_compound_pattern_tuple_prefix<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn read_compound_pattern_tuple_prefix<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -400,7 +402,7 @@ fn read_compound_pattern_tuple_prefix<'de, _Any: preserves::value::NestedValue,
     Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
 }
 
-fn read_compound_pattern_dict<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn read_compound_pattern_dict<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -420,7 +422,7 @@ fn read_compound_pattern_dict<'de, _Any: preserves::value::NestedValue, R: _supp
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for CompoundPattern<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for CompoundPattern<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -431,7 +433,7 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_compound_pattern_rec<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn parse_compound_pattern_rec<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); }
     let _tmp1 = ();
@@ -441,7 +443,7 @@ fn parse_compound_pattern_rec<_Any: preserves::value::NestedValue>(_ctxt: &crate
     Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
 }
 
-fn parse_compound_pattern_tuple<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn parse_compound_pattern_tuple<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); }
     let _tmp1 = ();
@@ -452,7 +454,7 @@ fn parse_compound_pattern_tuple<_Any: preserves::value::NestedValue>(_ctxt: &cra
     Ok(CompoundPattern::Tuple {patterns: _tmp2})
 }
 
-fn parse_compound_pattern_tuple_prefix<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn parse_compound_pattern_tuple_prefix<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); }
     let _tmp1 = ();
@@ -464,7 +466,7 @@ fn parse_compound_pattern_tuple_prefix<_Any: preserves::value::NestedValue>(_ctx
     Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
 }
 
-fn parse_compound_pattern_dict<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<CompoundPattern<_Any>, _support::ParseError> {
+fn parse_compound_pattern_dict<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); }
     let _tmp1 = ();
@@ -473,8 +475,8 @@ fn parse_compound_pattern_dict<_Any: preserves::value::NestedValue>(_ctxt: &crat
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for CompoundPattern<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_compound_pattern_rec(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_compound_pattern_tuple(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_compound_pattern_tuple_prefix(_ctxt, value) { return Ok(r); }
@@ -483,8 +485,8 @@ impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for CompoundPattern<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
                 let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_9_REC).clone()]);
@@ -525,23 +527,23 @@ impl<_Any: preserves::value::NestedValue> CompoundPattern<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Definition<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum Definition<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
     Or {
-        pattern_0: std::boxed::Box<NamedAlternative<_Any>>,
-        pattern_1: std::boxed::Box<NamedAlternative<_Any>>,
-        pattern_n: std::vec::Vec<NamedAlternative<_Any>>
+        pattern_0: std::boxed::Box<NamedAlternative<_Value>>,
+        pattern_1: std::boxed::Box<NamedAlternative<_Value>>,
+        pattern_n: std::vec::Vec<NamedAlternative<_Value>>
     },
     And {
-        pattern_0: std::boxed::Box<NamedPattern<_Any>>,
-        pattern_1: std::boxed::Box<NamedPattern<_Any>>,
-        pattern_n: std::vec::Vec<NamedPattern<_Any>>
+        pattern_0: std::boxed::Box<NamedPattern<_Value>>,
+        pattern_1: std::boxed::Box<NamedPattern<_Value>>,
+        pattern_n: std::vec::Vec<NamedPattern<_Value>>
     },
-    Pattern(std::boxed::Box<Pattern<_Any>>)
+    Pattern(std::boxed::Box<Pattern<_Value>>)
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Definition<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Definition<_Value> {}
 
-fn read_definition_or<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn read_definition_or<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -580,7 +582,7 @@ fn read_definition_or<'de, _Any: preserves::value::NestedValue, R: _support::Rea
     })
 }
 
-fn read_definition_and<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn read_definition_and<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -619,12 +621,12 @@ fn read_definition_and<'de, _Any: preserves::value::NestedValue, R: _support::Re
     })
 }
 
-fn read_definition_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn read_definition_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::deserialize(r)?;
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definition<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Definition<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -634,7 +636,7 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_definition_or<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn parse_definition_or<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); }
     let _tmp1 = ();
@@ -652,7 +654,7 @@ fn parse_definition_or<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::
     })
 }
 
-fn parse_definition_and<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn parse_definition_and<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); }
     let _tmp1 = ();
@@ -670,13 +672,13 @@ fn parse_definition_and<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen:
     })
 }
 
-fn parse_definition_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Definition<_Any>, _support::ParseError> {
+fn parse_definition_pattern<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::parse(_ctxt, value)?;
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<_Any: preserves::value::NestedValue> Definition<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Definition<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_definition_or(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_definition_and(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_definition_pattern(_ctxt, value) { return Ok(r); }
@@ -684,8 +686,8 @@ impl<_Any: preserves::value::NestedValue> Definition<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Definition<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Definition<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
                 let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_13_OR).clone()]);
@@ -719,11 +721,11 @@ impl<_Any: preserves::value::NestedValue> Definition<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Definitions<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<std::string::String, Definition<_Any>>);
+pub struct Definitions<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<std::string::String, Definition<_Value>>);
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Definitions<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Definitions<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definitions<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Definitions<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -742,8 +744,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Definitions<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Definitions<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = _tmp1.value().to_symbol()?;
@@ -754,19 +756,19 @@ impl<_Any: preserves::value::NestedValue> Definitions<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Definitions<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Definitions<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Definitions(_tmp0) = self;
         preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _tmp2.unparse(_ctxt))).collect()).wrap()
     }
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct DictionaryEntries<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<_Any, NamedSimplePattern<_Any>>);
+pub struct DictionaryEntries<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for DictionaryEntries<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for DictionaryEntries<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for DictionaryEntries<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for DictionaryEntries<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -785,8 +787,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> DictionaryEntries<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for DictionaryEntries<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = _tmp1;
@@ -797,8 +799,8 @@ impl<_Any: preserves::value::NestedValue> DictionaryEntries<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> DictionaryEntries<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for DictionaryEntries<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let DictionaryEntries(_tmp0) = self;
         preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap()
     }
@@ -812,12 +814,12 @@ pub enum EmbeddedTypeName {
 
 impl preserves::value::Domain for EmbeddedTypeName {}
 
-fn read_embedded_type_name_ref<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn read_embedded_type_name_ref<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     let _tmp0 = Ref::deserialize(r)?;
     Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_embedded_type_name_false<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn read_embedded_type_name_false<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Boolean(w) if !*w => {}
@@ -829,7 +831,7 @@ fn read_embedded_type_name_false<'de, _Any: preserves::value::NestedValue, R: _s
     Ok(EmbeddedTypeName::False)
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for EmbeddedTypeName {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for EmbeddedTypeName {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -838,27 +840,27 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_embedded_type_name_ref<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn parse_embedded_type_name_ref<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     let _tmp0 = Ref::parse(_ctxt, value)?;
     Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-fn parse_embedded_type_name_false<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn parse_embedded_type_name_false<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     if value != &_ctxt.LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); }
     let _tmp0 = ();
     Ok(EmbeddedTypeName::False)
 }
 
-impl EmbeddedTypeName {
-    pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for EmbeddedTypeName {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_embedded_type_name_ref(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_embedded_type_name_false(_ctxt, value) { return Ok(r); }
         Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName"))
     }
 }
 
-impl EmbeddedTypeName {
-    pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for EmbeddedTypeName {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             EmbeddedTypeName::Ref(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             EmbeddedTypeName::False => (&_ctxt.LIT_15_FALSE).clone(),
@@ -871,7 +873,7 @@ pub struct ModulePath(pub std::vec::Vec<std::string::String>);
 
 impl preserves::value::Domain for ModulePath {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for ModulePath {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for ModulePath {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_sequence()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -887,8 +889,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl ModulePath {
-    pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for ModulePath {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp1 = value.value().to_sequence()?;
         let mut _tmp0 = std::vec::Vec::new();
         for _tmp2 in &_tmp1[0..] {let _tmp3 = _tmp2.value().to_symbol()?; _tmp0.push(_tmp3.clone());}
@@ -896,8 +898,8 @@ impl ModulePath {
     }
 }
 
-impl ModulePath {
-    pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for ModulePath {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let ModulePath(_tmp0) = self;
         {
             let mut _tmp1 = std::vec::Vec::new();
@@ -908,11 +910,11 @@ impl ModulePath {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Modules<_Any: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<ModulePath, Schema<_Any>>);
+pub struct Modules<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<ModulePath, Schema<_Value>>);
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Modules<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Modules<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Modules<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Modules<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -931,8 +933,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Modules<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Modules<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = ModulePath::parse(_ctxt, _tmp1)?;
@@ -943,22 +945,22 @@ impl<_Any: preserves::value::NestedValue> Modules<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Modules<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Modules<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Modules(_tmp0) = self;
         preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.unparse(_ctxt), _tmp2.unparse(_ctxt))).collect()).wrap()
     }
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct NamedAlternative<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct NamedAlternative<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
     pub variant_label: std::string::String,
-    pub pattern: Pattern<_Any>
+    pub pattern: Pattern<_Value>
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedAlternative<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedAlternative<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedAlternative<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for NamedAlternative<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_sequence()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -973,8 +975,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for NamedAlternative<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp0 = value.value().to_sequence()?;
         if _tmp0.len() < 2 { return Err(_support::ParseError::conformance_error("schema.NamedAlternative")); }
         let _tmp1 = (&_tmp0[0]).value().to_string()?;
@@ -983,8 +985,8 @@ impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for NamedAlternative<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = self;
         {
             let mut _tmp2 = std::vec::Vec::new();
@@ -996,24 +998,24 @@ impl<_Any: preserves::value::NestedValue> NamedAlternative<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedPattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
-    Named(std::boxed::Box<Binding<_Any>>),
-    Anonymous(std::boxed::Box<Pattern<_Any>>)
+pub enum NamedPattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+    Named(std::boxed::Box<Binding<_Value>>),
+    Anonymous(std::boxed::Box<Pattern<_Value>>)
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedPattern<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedPattern<_Value> {}
 
-fn read_named_pattern_named<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<NamedPattern<_Any>, _support::ParseError> {
+fn read_named_pattern_named<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::deserialize(r)?;
     Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_named_pattern_anonymous<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<NamedPattern<_Any>, _support::ParseError> {
+fn read_named_pattern_anonymous<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::deserialize(r)?;
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedPattern<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for NamedPattern<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -1022,26 +1024,26 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_named_pattern_named<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<NamedPattern<_Any>, _support::ParseError> {
+fn parse_named_pattern_named<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::parse(_ctxt, value)?;
     Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn parse_named_pattern_anonymous<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<NamedPattern<_Any>, _support::ParseError> {
+fn parse_named_pattern_anonymous<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::parse(_ctxt, value)?;
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<_Any: preserves::value::NestedValue> NamedPattern<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for NamedPattern<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_named_pattern_named(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_named_pattern_anonymous(_ctxt, value) { return Ok(r); }
         Err(_support::ParseError::conformance_error("schema.NamedPattern"))
     }
 }
 
-impl<_Any: preserves::value::NestedValue> NamedPattern<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for NamedPattern<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             NamedPattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             NamedPattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1050,24 +1052,24 @@ impl<_Any: preserves::value::NestedValue> NamedPattern<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedSimplePattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
-    Named(std::boxed::Box<Binding<_Any>>),
-    Anonymous(std::boxed::Box<SimplePattern<_Any>>)
+pub enum NamedSimplePattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+    Named(std::boxed::Box<Binding<_Value>>),
+    Anonymous(std::boxed::Box<SimplePattern<_Value>>)
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for NamedSimplePattern<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedSimplePattern<_Value> {}
 
-fn read_named_simple_pattern_named<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern<_Any>, _support::ParseError> {
+fn read_named_simple_pattern_named<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::deserialize(r)?;
     Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_named_simple_pattern_anonymous<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern<_Any>, _support::ParseError> {
+fn read_named_simple_pattern_anonymous<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::deserialize(r)?;
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedSimplePattern<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for NamedSimplePattern<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -1076,26 +1078,26 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_named_simple_pattern_named<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<NamedSimplePattern<_Any>, _support::ParseError> {
+fn parse_named_simple_pattern_named<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::parse(_ctxt, value)?;
     Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn parse_named_simple_pattern_anonymous<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<NamedSimplePattern<_Any>, _support::ParseError> {
+fn parse_named_simple_pattern_anonymous<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::parse(_ctxt, value)?;
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<_Any: preserves::value::NestedValue> NamedSimplePattern<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for NamedSimplePattern<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_named_simple_pattern_named(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_named_simple_pattern_anonymous(_ctxt, value) { return Ok(r); }
         Err(_support::ParseError::conformance_error("schema.NamedSimplePattern"))
     }
 }
 
-impl<_Any: preserves::value::NestedValue> NamedSimplePattern<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for NamedSimplePattern<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             NamedSimplePattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             NamedSimplePattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1104,24 +1106,24 @@ impl<_Any: preserves::value::NestedValue> NamedSimplePattern<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Pattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
-    SimplePattern(std::boxed::Box<SimplePattern<_Any>>),
-    CompoundPattern(std::boxed::Box<CompoundPattern<_Any>>)
+pub enum Pattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+    SimplePattern(std::boxed::Box<SimplePattern<_Value>>),
+    CompoundPattern(std::boxed::Box<CompoundPattern<_Value>>)
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Pattern<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Pattern<_Value> {}
 
-fn read_pattern_simple_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<Pattern<_Any>, _support::ParseError> {
+fn read_pattern_simple_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::deserialize(r)?;
     Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_pattern_compound_pattern<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<Pattern<_Any>, _support::ParseError> {
+fn read_pattern_compound_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = CompoundPattern::deserialize(r)?;
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Pattern<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Pattern<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -1130,26 +1132,26 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_pattern_simple_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Pattern<_Any>, _support::ParseError> {
+fn parse_pattern_simple_pattern<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::parse(_ctxt, value)?;
     Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
 }
 
-fn parse_pattern_compound_pattern<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Pattern<_Any>, _support::ParseError> {
+fn parse_pattern_compound_pattern<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = CompoundPattern::parse(_ctxt, value)?;
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<_Any: preserves::value::NestedValue> Pattern<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Pattern<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_pattern_simple_pattern(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_pattern_compound_pattern(_ctxt, value) { return Ok(r); }
         Err(_support::ParseError::conformance_error("schema.Pattern"))
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Pattern<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Pattern<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             Pattern::SimplePattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             Pattern::CompoundPattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1165,7 +1167,7 @@ pub struct Ref {
 
 impl preserves::value::Domain for Ref {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Ref {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Ref {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_record(None)?;
         let mut _tmp0 = _support::B::Type::default();
@@ -1190,8 +1192,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl Ref {
-    pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Ref {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp0 = value.value().to_record(None)?;
         if _tmp0.label() != &_ctxt.LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); }
         let _tmp1 = ();
@@ -1202,8 +1204,8 @@ impl Ref {
     }
 }
 
-impl Ref {
-    pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Ref {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Ref {module: _tmp0, name: _tmp1} = self;
         {
             let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_16_REF).clone()]);
@@ -1215,15 +1217,15 @@ impl Ref {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Schema<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
-    pub definitions: Definitions<_Any>,
+pub struct Schema<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+    pub definitions: Definitions<_Value>,
     pub embedded_type: EmbeddedTypeName,
     pub version: Version
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for Schema<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Schema<_Value> {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Schema<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Schema<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         r.open_record(None)?;
         let mut _tmp0 = _support::B::Type::default();
@@ -1281,8 +1283,8 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Schema<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Schema<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         let _tmp0 = value.value().to_record(None)?;
         if _tmp0.label() != &_ctxt.LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); }
         let _tmp1 = ();
@@ -1298,8 +1300,8 @@ impl<_Any: preserves::value::NestedValue> Schema<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> Schema<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Schema<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = self;
         {
             let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_17_SCHEMA).clone()]);
@@ -1318,33 +1320,33 @@ impl<_Any: preserves::value::NestedValue> Schema<_Any> {
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum SimplePattern<_Any: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum SimplePattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
     Any,
     Atom {
         atom_kind: std::boxed::Box<AtomKind>
     },
     Embedded {
-        interface: std::boxed::Box<SimplePattern<_Any>>
+        interface: std::boxed::Box<SimplePattern<_Value>>
     },
     Lit {
-        value: _Any
+        value: _Value
     },
     Seqof {
-        pattern: std::boxed::Box<SimplePattern<_Any>>
+        pattern: std::boxed::Box<SimplePattern<_Value>>
     },
     Setof {
-        pattern: std::boxed::Box<SimplePattern<_Any>>
+        pattern: std::boxed::Box<SimplePattern<_Value>>
     },
     Dictof {
-        key: std::boxed::Box<SimplePattern<_Any>>,
-        value: std::boxed::Box<SimplePattern<_Any>>
+        key: std::boxed::Box<SimplePattern<_Value>>,
+        value: std::boxed::Box<SimplePattern<_Value>>
     },
     Ref(std::boxed::Box<Ref>)
 }
 
-impl<_Any: preserves::value::NestedValue> preserves::value::Domain for SimplePattern<_Any> {}
+impl<_Value: preserves::value::NestedValue> preserves::value::Domain for SimplePattern<_Value> {}
 
-fn read_simple_pattern_any<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_any<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     match r.next_token(true)? {
         preserves::value::Token::Atom(v) => match v.value() {
             preserves::value::Value::Symbol(w) if w == "any" => {}
@@ -1356,7 +1358,7 @@ fn read_simple_pattern_any<'de, _Any: preserves::value::NestedValue, R: _support
     Ok(SimplePattern::Any)
 }
 
-fn read_simple_pattern_atom<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_atom<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1376,7 +1378,7 @@ fn read_simple_pattern_atom<'de, _Any: preserves::value::NestedValue, R: _suppor
     Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_embedded<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_embedded<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1396,7 +1398,7 @@ fn read_simple_pattern_embedded<'de, _Any: preserves::value::NestedValue, R: _su
     Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_lit<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_lit<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1416,7 +1418,7 @@ fn read_simple_pattern_lit<'de, _Any: preserves::value::NestedValue, R: _support
     Ok(SimplePattern::Lit {value: _tmp2})
 }
 
-fn read_simple_pattern_seqof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_seqof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1436,7 +1438,7 @@ fn read_simple_pattern_seqof<'de, _Any: preserves::value::NestedValue, R: _suppo
     Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_setof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_setof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1456,7 +1458,7 @@ fn read_simple_pattern_setof<'de, _Any: preserves::value::NestedValue, R: _suppo
     Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_dictof<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_dictof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.open_record(None)?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1479,12 +1481,12 @@ fn read_simple_pattern_dictof<'de, _Any: preserves::value::NestedValue, R: _supp
     Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
 }
 
-fn read_simple_pattern_ref<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn read_simple_pattern_ref<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Ref::deserialize(r)?;
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for SimplePattern<_Any> {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for SimplePattern<_Value> {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.mark()?;
         match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
@@ -1499,13 +1501,13 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-fn parse_simple_pattern_any<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_any<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     if value != &_ctxt.LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); }
     let _tmp0 = ();
     Ok(SimplePattern::Any)
 }
 
-fn parse_simple_pattern_atom<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_atom<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); }
     let _tmp1 = ();
@@ -1514,7 +1516,7 @@ fn parse_simple_pattern_atom<_Any: preserves::value::NestedValue>(_ctxt: &crate:
     Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
 }
 
-fn parse_simple_pattern_embedded<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_embedded<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); }
     let _tmp1 = ();
@@ -1523,7 +1525,7 @@ fn parse_simple_pattern_embedded<_Any: preserves::value::NestedValue>(_ctxt: &cr
     Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
 }
 
-fn parse_simple_pattern_lit<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_lit<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); }
     let _tmp1 = ();
@@ -1532,7 +1534,7 @@ fn parse_simple_pattern_lit<_Any: preserves::value::NestedValue>(_ctxt: &crate::
     Ok(SimplePattern::Lit {value: _tmp2.clone()})
 }
 
-fn parse_simple_pattern_seqof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_seqof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); }
     let _tmp1 = ();
@@ -1541,7 +1543,7 @@ fn parse_simple_pattern_seqof<_Any: preserves::value::NestedValue>(_ctxt: &crate
     Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn parse_simple_pattern_setof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_setof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); }
     let _tmp1 = ();
@@ -1550,7 +1552,7 @@ fn parse_simple_pattern_setof<_Any: preserves::value::NestedValue>(_ctxt: &crate
     Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn parse_simple_pattern_dictof<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_dictof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = value.value().to_record(None)?;
     if _tmp0.label() != &_ctxt.LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); }
     let _tmp1 = ();
@@ -1560,13 +1562,13 @@ fn parse_simple_pattern_dictof<_Any: preserves::value::NestedValue>(_ctxt: &crat
     Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
 }
 
-fn parse_simple_pattern_ref<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<SimplePattern<_Any>, _support::ParseError> {
+fn parse_simple_pattern_ref<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Ref::parse(_ctxt, value)?;
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl<_Any: preserves::value::NestedValue> SimplePattern<_Any> {
-    pub fn parse(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for SimplePattern<_Value> {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if let Ok(r) = parse_simple_pattern_any(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_simple_pattern_atom(_ctxt, value) { return Ok(r); }
         if let Ok(r) = parse_simple_pattern_embedded(_ctxt, value) { return Ok(r); }
@@ -1579,8 +1581,8 @@ impl<_Any: preserves::value::NestedValue> SimplePattern<_Any> {
     }
 }
 
-impl<_Any: preserves::value::NestedValue> SimplePattern<_Any> {
-    pub fn unparse(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for SimplePattern<_Value> {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {
         match self {
             SimplePattern::Any => (&_ctxt.LIT_21_ANY).clone(),
             SimplePattern::Atom {atom_kind: _tmp0} => {
@@ -1624,7 +1626,7 @@ pub struct Version;
 
 impl preserves::value::Domain for Version {}
 
-impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Version {
+impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>> _support::Deserialize<'de, _Value, R> for Version {
     fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
         match r.next_token(true)? {
             preserves::value::Token::Atom(v) => match v.value() {
@@ -1638,14 +1640,14 @@ impl<'de, _Any: preserves::value::NestedValue, R: _support::Reader<'de, _Any>> _
     }
 }
 
-impl Version {
-    pub fn parse<_Any: preserves::value::NestedValue>(_ctxt: &crate::gen::Literals<_Any>, value: &_Any) -> std::result::Result<Self, _support::ParseError> {
+impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Literals<_Value>, _Value> for Version {
+    fn parse(_ctxt: &crate::gen::Literals<_Value>, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
         if value != &_ctxt.LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); }
         let _tmp0 = ();
         Ok(Version)
     }
 }
 
-impl Version {
-    pub fn unparse<_Any: preserves::value::NestedValue>(&self, _ctxt: &crate::gen::Literals<_Any>) -> _Any {let Version = self; (&_ctxt.LIT_28_1).clone()}
+impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Literals<_Value>, _Value> for Version {
+    fn unparse(&self, _ctxt: &crate::gen::Literals<_Value>) -> _Value {let Version = self; (&_ctxt.LIT_28_1).clone()}
 }
diff --git a/implementations/rust/preserves-schema/src/lib.rs b/implementations/rust/preserves-schema/src/lib.rs
index 0101030..ae600a0 100644
--- a/implementations/rust/preserves-schema/src/lib.rs
+++ b/implementations/rust/preserves-schema/src/lib.rs
@@ -3,6 +3,12 @@ pub mod compiler;
 pub mod support;
 pub mod gen;
 
+pub use support::Codec;
+pub use support::Deserialize;
+pub use support::Parse;
+pub use support::ParseError;
+pub use support::Unparse;
+
 #[cfg(test)]
 mod tests {
     #[test]
@@ -32,6 +38,8 @@ mod tests {
     #[test]
     fn metaschema_parsing() -> Result<(), std::io::Error> {
         use preserves::value::{BinarySource, IOBinarySource, Reader};
+        use crate::Parse;
+        use crate::Unparse;
         use crate::gen::schema::*;
 
         let mut f = std::fs::File::open("../../../schema/schema.bin")?;
diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs
index 6e406d1..5122dd4 100644
--- a/implementations/rust/preserves-schema/src/support/mod.rs
+++ b/implementations/rust/preserves-schema/src/support/mod.rs
@@ -19,18 +19,46 @@ use std::sync::Arc;
 
 use thiserror::Error;
 
-pub struct Codec<N: NestedValue, L: Default> {
+pub trait Parse<L, Value: NestedValue>: Sized {
+    fn parse(literals: &L, value: &Value) -> Result<Self, ParseError>;
+}
+
+impl<L, Value: NestedValue> Parse<L, Value> for Value {
+    fn parse(_literals: &L, value: &Value) -> Result<Self, ParseError> {
+        Ok(value.clone())
+    }
+}
+
+pub trait Unparse<L, Value: NestedValue> {
+    fn unparse(&self, literals: &L) -> Value;
+}
+
+impl<L, Value: NestedValue> Unparse<L, Value> for Value {
+    fn unparse(&self, _literals: &L) -> Value {
+        self.clone()
+    }
+}
+
+pub struct Codec<L: Default, N: NestedValue> {
     pub literals: L,
     phantom: PhantomData<N>,
 }
 
-impl<N: NestedValue, L: Default> Codec<N, L> {
+impl<L: Default, N: NestedValue> Codec<L, N> {
     pub fn new() -> Self {
         Codec {
             literals: L::default(),
             phantom: PhantomData,
         }
     }
+
+    pub fn parse<T: Parse<L, N>>(&self, value: &N) -> Result<T, ParseError> {
+        T::parse(&self.literals, value)
+    }
+
+    pub fn unparse<T: Unparse<L, N>>(&self, value: &T) -> N {
+        value.unparse(&self.literals)
+    }
 }
 
 pub trait Deserialize<'de, N: NestedValue, R: Reader<'de, N>>