Steps toward better cross-compilation-unit handling of Languages

2021-09-16 16:31:59 +02:00 · 2021-09-16 16:31:59 +02:00 · 8d587c0aaa
parent d872f7cf8a
commit 8d587c0aaa
9 changed files with 277 additions and 166 deletions
--- a/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
+++ b/implementations/rust/preserves-schema/src/bin/preserves-schema-rs.rs
@ -3,7 +3,7 @@ use std::io::ErrorKind;
 use std::path::PathBuf;
 use structopt::StructOpt;

-use preserves_schema::compiler::{CompilerConfig, compile, expand_inputs};
+use preserves_schema::compiler::{ExternalModule, CompilerConfig, compile, expand_inputs};

 #[derive(Clone, StructOpt, Debug)]
 struct CommandLine {
@ -35,7 +35,11 @@ fn main() -> Result<(), Error> {
            (pieces[0], pieces[1])
        };
        let modulepath: Vec<String> = modulepath_str.split('.').map(str::to_owned).collect();
-        config.module_aliases.insert(modulepath, target.to_owned());
+        config.add_external_module(ExternalModule {
+            path: modulepath,
+            rust_namespace: target.to_owned(),
+            rust_language_type: None,
+        });
    }
    if let Some(c) = args.support_crate {
        config.support_crate = c;
--- a/implementations/rust/preserves-schema/src/compiler/context.rs
+++ b/implementations/rust/preserves-schema/src/compiler/context.rs
@ -83,7 +83,7 @@ impl<'b> BundleContext<'b> {
            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) {
+        if result.is_none() && !self.config.external_modules.contains_key(&r.module.0) {
            panic!("Attempted to lookup unknown type {:?}", r)
        }
        result
@ -151,7 +151,7 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
    }

    pub fn render_ref(&self, r: &Ref, style: RefRenderStyle) -> Item {
-        let base = match self.bundle.config.module_aliases.get(&r.module.0) {
+        let base = match self.bundle.config.external_modules.get(&r.module.0) {
            None =>
                if r.module.0.is_empty() {
                    item(r.name.to_owned())
@ -162,8 +162,8 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
                    items.push(item(r.name.to_owned()));
                    item(name(items))
                }
-            Some(s) =>
-                item(name![s.to_owned(), r.name.to_owned()])
+            Some(xm) =>
+                item(name![xm.rust_namespace.clone(), r.name.to_owned()])
        };
        let q = self.ref_has_embedded(r);
        match style {
@ -188,6 +188,10 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
        item(anglebrackets!["_Value: preserves::value::NestedValue"])
    }

+    pub fn generic_static_decls(&self) -> Item {
+        item(anglebrackets!["_Value: preserves::value::NestedValue + 'static"])
+    }
+
    pub fn generic_decls_with_defaults(&self) -> Item {
        item(anglebrackets![
            seq!["_Value: preserves::value::NestedValue = ",
--- a/implementations/rust/preserves-schema/src/compiler/mod.rs
+++ b/implementations/rust/preserves-schema/src/compiler/mod.rs
@ -39,13 +39,20 @@ pub trait Plugin: std::fmt::Debug {
    );
 }

+#[derive(Debug)]
+pub struct ExternalModule {
+    pub path: ModulePath,
+    pub rust_namespace: String,
+    pub rust_language_type: Option<String>,
+}
+
 #[derive(Debug)]
 pub struct CompilerConfig {
    pub bundle: Map<ModulePath, Schema>,
    pub output_dir: PathBuf,
    pub fully_qualified_module_prefix: String,
    pub support_crate: String,
-    pub module_aliases: Map<ModulePath, String>,
+    pub external_modules: Map<ModulePath, ExternalModule>,
    pub plugins: Vec<Box<dyn Plugin>>,
 }

@ -59,7 +66,7 @@ impl CompilerConfig {
            output_dir: output_dir,
            fully_qualified_module_prefix: fully_qualified_module_prefix,
            support_crate: "preserves_schema".to_owned(),
-            module_aliases: Map::new(),
+            external_modules: Map::new(),
            plugins: vec![
                Box::new(types::TypePlugin),
                Box::new(readers::ReaderPlugin),
@ -69,6 +76,13 @@ impl CompilerConfig {
        }
    }

+    pub fn add_external_module(&mut self, m: ExternalModule) {
+        let path = m.path.clone();
+        if self.external_modules.insert(path.clone(), m).is_some() {
+            panic!("Duplicate external module installed: {:?}", path)
+        }
+    }
+
    pub fn load_schemas_and_bundles(&mut self, inputs: &Vec<PathBuf>) -> io::Result<()> {
        for i in inputs {
            let mut f = File::open(&i)?;
@ -253,8 +267,8 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> {
        lines.push("".to_owned());
        lines.push(Formatter::to_string(item(seq![
            "impl", anglebrackets!["N: preserves::value::NestedValue"],
-            " Default for Language<N> ", block![
-                seq!["fn default() -> Self ", block![
+            " Default for Language<N> ", codeblock![
+                seq!["fn default() -> Self ", codeblock![
                    seq!["Language ", vertical(false, braces(b.literals.iter().map(|(value, name)| {
                        let bs = preserves::value::PackedWriter::encode_iovalue(&value).unwrap();
                        item(format!("{}: /* {:?} */ _support::decode_lit(&vec!{:?}).unwrap()",
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@ -43,7 +43,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                                let dest = pattern_parser(&mut ctxt, pat, "value", None, &mut body);
                                let dest = dest.as_ref().map(String::as_str);
                                construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
-                                item(seq!["fn ", fname.clone(), ctxt.m.generic_decls(),
+                                item(seq!["fn ", fname.clone(), ctxt.m.generic_static_decls(),
                                          "(_ctxt: &", ctxt.m.language_type(), ", value: &", ctxt.m.any_type(), ") -> ",
                                          "std::result::Result<",
                                          names::render_constructor(n), ty.generic_arg(ctxt.m),
@ -69,12 +69,12 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                }
            }

-            item(seq!["impl", ctxt.m.generic_decls(),
-                      " _support::Parse", anglebrackets![ctxt.m.language_type(),
-                                                         ctxt.m.any_type()], " for ",
+            item(seq!["impl", ctxt.m.generic_static_decls(),
+                      " _support::Parse", anglebrackets![ctxt.m.any_type()], " for ",
                      names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
-                      block![
-                          seq!["fn parse<'a, _LL: Into<&'a ", ctxt.m.language_type(), ">>",
+                      codeblock![
+                          "type Language = crate::gen::Language<_Value>;",
+                          seq!["fn parse<'a, _LL: Into<&'a Self::Language>>",
                               "(_ctxt: _LL, value: &", ctxt.m.any_type(), ") ",
                               " -> std::result::Result<Self, _support::ParseError>",
                               " where ", ctxt.m.language_type(), ": 'a ",
@ -166,7 +166,7 @@ fn simple_pattern_parser(
            ctxt.declare_compound(body, &dest, item("std::vec::Vec::new()"));
            body.push(item(seq!["for ", tmp.to_owned(),
                                " in &", src.to_owned(), brackets![seq![n.to_string() , ".."]],
-                                " ", block(inner)]));
+                                " ", codeblock(inner)]));
            dest
        },
        SimplePattern::Setof { pattern } => {
@ -178,7 +178,7 @@ fn simple_pattern_parser(
            ctxt.declare_compound(body, &dest, item("preserves::value::Set::new()"));
            body.push(item(seq!["for ", tmp.to_owned(),
                                " in ", src.to_owned(), ".value().to_set()?",
-                                " ", block(inner)]));
+                                " ", codeblock(inner)]));
            dest
        },
        SimplePattern::Dictof { key, value } => {
@ -194,7 +194,7 @@ fn simple_pattern_parser(
            ctxt.declare_compound(body, &dest, item("preserves::value::Map::new()"));
            body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
                                " in ", src.to_owned(), ".value().to_dictionary()?",
-                                " ", block(inner)]));
+                                " ", codeblock(inner)]));
            dest
        },
        SimplePattern::Ref(r) => {
--- a/implementations/rust/preserves-schema/src/compiler/readers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/readers.rs
@ -73,7 +73,7 @@ impl BoundaryTracker {
            "while !r.close_compound", parens![
                seq!["&mut ", self.tracker_name.clone()],
                seq!["&", self.item_expr]], "? ",
-            block(inner)]))
+            codeblock(inner)]))
    }
 }

@ -109,7 +109,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
                                    "std::result::Result<",
                                    names::render_constructor(n), ty.generic_arg(ctxt.m),
                                    ", _support::ParseError> ",
-                                    block(body)])
+                                    codeblock(body)])
                            });
                        body.push(item(seq![
                            "match ", fname, "(r) { ",
@ -145,10 +145,10 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
                                       "_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![
+                "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", codeblock![
                    seq!["fn deserialize(r: &mut R) -> ",
                         "std::result::Result<Self, _support::ParseError> ",
-                         block(body)]]])
+                         codeblock(body)]]])
        });
 }

@ -238,7 +238,7 @@ fn read_expected_literal_seqs(
            None => {
                let mut inner = Vec::new();
                group.into_iter().next().unwrap().1(ctxt, &mut inner);
-                cases.push(item(seq!["preserves::value::Token::End => ", block(inner)]));
+                cases.push(item(seq!["preserves::value::Token::End => ", codeblock(inner)]));
            },
            Some(h) => {
                let tails = group.into_iter().map(|(mut vs, f)| {
@ -252,7 +252,7 @@ fn read_expected_literal_seqs(
        }
    }
    cases.extend(read_expected_literals_cases(ctxt, nested));
-    body.push(item(seq!["match r.next_token(true)? ", block(cases)]));
+    body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)]));
 }

 fn read_expected_literals_cases(
@ -287,10 +287,10 @@ fn read_expected_literals_cases(
                                format!(" if w == {}", escape_string(p.0.value().to_symbol().unwrap())),
                        },
                        " => ",
-                        block(inner)]));
+                        codeblock(inner)]));
                }
                subcases.push(item(seq!["_ => return ", ctxt.err_code(), "?,"]));
-                item(seq!["preserves::value::Token::Atom(v) => match v.value() ", block(subcases)])
+                item(seq!["preserves::value::Token::Atom(v) => match v.value() ", codeblock(subcases)])
            }
            ValueClass::Compound(CompoundClass::Record) => {
                let mut subcases = Vec::new();
@ -300,7 +300,7 @@ fn read_expected_literals_cases(
                }).collect());
                item(seq![
                    "preserves::value::Token::Compound(preserves::value::CompoundClass::Record) => ",
-                    block(subcases)])
+                    codeblock(subcases)])
            }
            ValueClass::Compound(CompoundClass::Sequence) => {
                let mut subcases = Vec::new();
@ -310,7 +310,7 @@ fn read_expected_literals_cases(
                }).collect());
                item(seq![
                    "preserves::value::Token::Compound(preserves::value::CompoundClass::Sequence) => ",
-                    block(subcases)])
+                    codeblock(subcases)])
            }
            ValueClass::Compound(CompoundClass::Set) => {
                panic!("Sets in literal constants in Schema not yet supported");
@ -333,7 +333,7 @@ fn read_expected_literals(
    possibilities: LiteralCases,
 ) {
    let cases = read_expected_literals_cases(ctxt, possibilities);
-    body.push(item(seq!["match r.next_token(true)? ", block(cases)]));
+    body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)]));
 }

 fn simple_pattern_reader(
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@ -72,7 +72,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
                Definition::Or { pattern_0, pattern_1, pattern_n } => {
                    let mut ps = vec![&**pattern_0, &**pattern_1];
                    ps.extend(pattern_n);
-                    body.push(item(seq!["match self ", block(ps.iter().map(
+                    body.push(item(seq!["match self ", codeblock(ps.iter().map(
                        | NamedAlternative { variant_label: name, pattern: pat } | ctxt.branch(|ctxt| {
                            let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
                            let (patpat, vc) = destruct(ctxt, ctorname, false, &pattern_type(pat));
@ -97,15 +97,15 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
                }
            }

-            item(seq!["impl", ctxt.m.generic_decls(),
-                      " _support::Unparse", anglebrackets![ctxt.m.language_type(),
-                                                           ctxt.m.any_type()], " for ",
+            item(seq!["impl", ctxt.m.generic_static_decls(),
+                      " _support::Unparse", anglebrackets![ctxt.m.any_type()], " for ",
                      names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
-                      block![
-                          seq!["fn unparse<'a, _LL: Into<&'a ", ctxt.m.language_type(), ">>",
+                      codeblock![
+                          "type Language = crate::gen::Language<_Value>;",
+                          seq!["fn unparse<'a, _LL: Into<&'a Self::Language>>",
                               "(&self, _ctxt: _LL) -> ", ctxt.m.any_type(),
                               " where ", ctxt.m.language_type(), ": 'a ",
-                               block(body)]]])
+                               codeblock(body)]]])
        });
 }

@ -162,7 +162,7 @@ fn simple_pattern_unparser(
            let tmp = ctxt.gentempname();
            fields_sink.body.push(item(seq![
                "for ", tmp.to_owned(), " in ",
-                src.as_ref().unwrap().to_owned(), " ", block![
+                src.as_ref().unwrap().to_owned(), " ", codeblock![
                    seq![fields_sink.vec_expr.clone(), ".push(",
                         simple_pattern_unparser(ctxt,
                                                 pattern,
@ -265,7 +265,7 @@ fn pattern_unparser(
                            named_pattern_unparser(ctxt, &promote(value_pat), &normal_none(vc.is_struct))], ";"]));
                    }
                    body.push(item(seq!["preserves::value::Value::Dictionary(", dtmp, ").wrap()"]));
-                    item(block(body))
+                    item(codeblock(body))
                }
            }
        },
@ -295,7 +295,7 @@ fn sequenceify<'a>(

 fn finish(mut fields_sink: FieldsSink) -> Item {
    fields_sink.body.push(fields_sink.finish);
-    item(block(fields_sink.body))
+    item(codeblock(fields_sink.body))
 }

 fn fixed_sequence_parser(
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@ -121,50 +121,51 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_atom_kind_boolean<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_boolean<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_float<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_double<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_signed_integer<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_string<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_byte_string<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+fn parse_atom_kind_symbol<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for AtomKind {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for AtomKind {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -177,8 +178,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for AtomKind {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for AtomKind {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            AtomKind::Boolean => (&_ctxt.LIT_0_BOOLEAN).clone(),
@ -225,8 +227,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Binding<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Binding<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let _tmp0 = value.value().to_record(None)?;
        if _tmp0.label() != &_ctxt.LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); }
@ -238,8 +241,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Binding<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Binding<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Binding {name: _tmp0, pattern: _tmp1} = self;
        {
@ -280,8 +284,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Bundle<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Bundle<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let _tmp0 = value.value().to_record(None)?;
        if _tmp0.label() != &_ctxt.LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); }
@ -292,8 +297,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Bundle<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Bundle<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Bundle {modules: _tmp0} = self;
        {
@ -439,7 +445,7 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_compound_pattern_rec<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn parse_compound_pattern_rec<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -449,30 +455,36 @@ fn parse_compound_pattern_rec<_Value: preserves::value::NestedValue>(_ctxt: &cra
    Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
 }

-fn parse_compound_pattern_tuple<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn parse_compound_pattern_tuple<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
    if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); }
    let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?;
    let mut _tmp2 = std::vec::Vec::new();
-    for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?; _tmp2.push(_tmp5);}
+    for _tmp4 in &_tmp3[0..] {
+        let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?;
+        _tmp2.push(_tmp5);
+    }
    Ok(CompoundPattern::Tuple {patterns: _tmp2})
 }

-fn parse_compound_pattern_tuple_prefix<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn parse_compound_pattern_tuple_prefix<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
    if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); }
    let _tmp3 = (&_tmp0.fields()[0]).value().to_sequence()?;
    let mut _tmp2 = std::vec::Vec::new();
-    for _tmp4 in &_tmp3[0..] {let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?; _tmp2.push(_tmp5);}
+    for _tmp4 in &_tmp3[0..] {
+        let _tmp5 = NamedPattern::parse(_ctxt, _tmp4)?;
+        _tmp2.push(_tmp5);
+    }
    let _tmp6 = NamedSimplePattern::parse(_ctxt, (&_tmp0.fields()[1]))?;
    Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
 }

-fn parse_compound_pattern_dict<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn parse_compound_pattern_dict<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -481,8 +493,9 @@ fn parse_compound_pattern_dict<_Value: preserves::value::NestedValue>(_ctxt: &cr
    Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for CompoundPattern<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for CompoundPattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -492,8 +505,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for CompoundPattern<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for CompoundPattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
@ -507,7 +521,9 @@ impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Langua
                _tmp1.fields_vec_mut().push(
                    {
                        let mut _tmp2 = std::vec::Vec::new();
-                        for _tmp3 in _tmp0 {_tmp2.push(_tmp3.unparse(_ctxt));}
+                        for _tmp3 in _tmp0 {
+                            _tmp2.push(_tmp3.unparse(_ctxt));
+                        }
                        preserves::value::Value::Sequence(_tmp2).wrap()
                    }
                );
@ -518,7 +534,9 @@ impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Langua
                _tmp2.fields_vec_mut().push(
                    {
                        let mut _tmp3 = std::vec::Vec::new();
-                        for _tmp4 in _tmp0 {_tmp3.push(_tmp4.unparse(_ctxt));}
+                        for _tmp4 in _tmp0 {
+                            _tmp3.push(_tmp4.unparse(_ctxt));
+                        }
                        preserves::value::Value::Sequence(_tmp3).wrap()
                    }
                );
@ -644,7 +662,7 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_definition_or<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn parse_definition_or<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -654,7 +672,10 @@ fn parse_definition_or<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen
    let _tmp3 = NamedAlternative::parse(_ctxt, (&_tmp2[0]))?;
    let _tmp4 = NamedAlternative::parse(_ctxt, (&_tmp2[1]))?;
    let mut _tmp5 = std::vec::Vec::new();
-    for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedAlternative::parse(_ctxt, _tmp6)?; _tmp5.push(_tmp7);}
+    for _tmp6 in &_tmp2[2..] {
+        let _tmp7 = NamedAlternative::parse(_ctxt, _tmp6)?;
+        _tmp5.push(_tmp7);
+    }
    Ok(Definition::Or {
        pattern_0: std::boxed::Box::new(_tmp3),
        pattern_1: std::boxed::Box::new(_tmp4),
@ -662,7 +683,7 @@ fn parse_definition_or<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen
    })
 }

-fn parse_definition_and<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn parse_definition_and<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -672,7 +693,10 @@ fn parse_definition_and<_Value: preserves::value::NestedValue>(_ctxt: &crate::ge
    let _tmp3 = NamedPattern::parse(_ctxt, (&_tmp2[0]))?;
    let _tmp4 = NamedPattern::parse(_ctxt, (&_tmp2[1]))?;
    let mut _tmp5 = std::vec::Vec::new();
-    for _tmp6 in &_tmp2[2..] {let _tmp7 = NamedPattern::parse(_ctxt, _tmp6)?; _tmp5.push(_tmp7);}
+    for _tmp6 in &_tmp2[2..] {
+        let _tmp7 = NamedPattern::parse(_ctxt, _tmp6)?;
+        _tmp5.push(_tmp7);
+    }
    Ok(Definition::And {
        pattern_0: std::boxed::Box::new(_tmp3),
        pattern_1: std::boxed::Box::new(_tmp4),
@ -680,13 +704,14 @@ fn parse_definition_and<_Value: preserves::value::NestedValue>(_ctxt: &crate::ge
    })
 }

-fn parse_definition_pattern<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn parse_definition_pattern<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Definition<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Definition<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        if let Ok(r) = parse_definition_or(_ctxt, value) { return Ok(r); }
        if let Ok(r) = parse_definition_and(_ctxt, value) { return Ok(r); }
@ -695,8 +720,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Definition<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Definition<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
@ -706,7 +732,9 @@ impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Langua
                        let mut _tmp4 = std::vec::Vec::new();
                        _tmp4.push(_tmp0.as_ref().unparse(_ctxt));
                        _tmp4.push(_tmp1.as_ref().unparse(_ctxt));
-                        for _tmp5 in _tmp2 {_tmp4.push(_tmp5.unparse(_ctxt));}
+                        for _tmp5 in _tmp2 {
+                            _tmp4.push(_tmp5.unparse(_ctxt));
+                        }
                        preserves::value::Value::Sequence(_tmp4).wrap()
                    }
                );
@ -719,7 +747,9 @@ impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Langua
                        let mut _tmp4 = std::vec::Vec::new();
                        _tmp4.push(_tmp0.as_ref().unparse(_ctxt));
                        _tmp4.push(_tmp1.as_ref().unparse(_ctxt));
-                        for _tmp5 in _tmp2 {_tmp4.push(_tmp5.unparse(_ctxt));}
+                        for _tmp5 in _tmp2 {
+                            _tmp4.push(_tmp5.unparse(_ctxt));
+                        }
                        preserves::value::Value::Sequence(_tmp4).wrap()
                    }
                );
@ -754,8 +784,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Definitions<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Definitions<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let mut _tmp0 = preserves::value::Map::new();
        for (_tmp1, _tmp2) in value.value().to_dictionary()? {
@ -767,8 +798,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Definitions<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Definitions<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Definitions(_tmp0) = self;
        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _tmp2.unparse(_ctxt))).collect()).wrap()
@ -799,8 +831,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for DictionaryEntries<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for DictionaryEntries<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let mut _tmp0 = preserves::value::Map::new();
        for (_tmp1, _tmp2) in value.value().to_dictionary()? {
@ -812,8 +845,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for DictionaryEntries<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for DictionaryEntries<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let DictionaryEntries(_tmp0) = self;
        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap()
@ -854,19 +888,20 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_embedded_type_name_ref<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn parse_embedded_type_name_ref<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn parse_embedded_type_name_false<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for EmbeddedTypeName {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for EmbeddedTypeName {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -874,8 +909,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for EmbeddedTypeName {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for EmbeddedTypeName {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            EmbeddedTypeName::Ref(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@ -905,23 +941,30 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for ModulePath {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for ModulePath {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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());}
+        for _tmp2 in &_tmp1[0..] {
+            let _tmp3 = _tmp2.value().to_symbol()?;
+            _tmp0.push(_tmp3.clone());
+        }
        Ok(ModulePath(_tmp0))
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for ModulePath {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for ModulePath {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let ModulePath(_tmp0) = self;
        {
            let mut _tmp1 = std::vec::Vec::new();
-            for _tmp2 in _tmp0 {_tmp1.push(preserves::value::Value::symbol(_tmp2).wrap());}
+            for _tmp2 in _tmp0 {
+                _tmp1.push(preserves::value::Value::symbol(_tmp2).wrap());
+            }
            preserves::value::Value::Sequence(_tmp1).wrap()
        }
    }
@ -951,8 +994,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Modules<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Modules<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let mut _tmp0 = preserves::value::Map::new();
        for (_tmp1, _tmp2) in value.value().to_dictionary()? {
@ -964,8 +1008,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Modules<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Modules<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Modules(_tmp0) = self;
        preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.unparse(_ctxt), _tmp2.unparse(_ctxt))).collect()).wrap()
@ -995,8 +1040,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for NamedAlternative<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for NamedAlternative<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let _tmp0 = value.value().to_sequence()?;
        if _tmp0.len() < 2 { return Err(_support::ParseError::conformance_error("schema.NamedAlternative")); }
@ -1006,8 +1052,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for NamedAlternative<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for NamedAlternative<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = self;
        {
@ -1046,18 +1093,19 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_named_pattern_named<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
+fn parse_named_pattern_named<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
+fn parse_named_pattern_anonymous<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for NamedPattern<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for NamedPattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -1065,8 +1113,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for NamedPattern<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for NamedPattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            NamedPattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@ -1102,18 +1151,19 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_named_simple_pattern_named<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
+fn parse_named_simple_pattern_named<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
+fn parse_named_simple_pattern_anonymous<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for NamedSimplePattern<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for NamedSimplePattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -1121,8 +1171,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for NamedSimplePattern<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for NamedSimplePattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            NamedSimplePattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@ -1158,18 +1209,19 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_pattern_simple_pattern<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
+fn parse_pattern_simple_pattern<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
+fn parse_pattern_compound_pattern<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Pattern<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Pattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -1177,8 +1229,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Pattern<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Pattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            Pattern::SimplePattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@ -1220,8 +1273,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Ref {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Ref {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let _tmp0 = value.value().to_record(None)?;
        if _tmp0.label() != &_ctxt.LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); }
@ -1233,8 +1287,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Ref {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Ref {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Ref {module: _tmp0, name: _tmp1} = self;
        {
@ -1313,8 +1368,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Schema<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Schema<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let _tmp0 = value.value().to_record(None)?;
        if _tmp0.label() != &_ctxt.LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); }
@ -1331,8 +1387,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Schema<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Schema<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = self;
        {
@ -1533,13 +1590,13 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-fn parse_simple_pattern_any<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_any<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_atom<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1548,7 +1605,7 @@ fn parse_simple_pattern_atom<_Value: preserves::value::NestedValue>(_ctxt: &crat
    Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
 }

-fn parse_simple_pattern_embedded<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_embedded<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1557,7 +1614,7 @@ fn parse_simple_pattern_embedded<_Value: preserves::value::NestedValue>(_ctxt: &
    Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
 }

-fn parse_simple_pattern_lit<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_lit<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1566,7 +1623,7 @@ fn parse_simple_pattern_lit<_Value: preserves::value::NestedValue>(_ctxt: &crate
    Ok(SimplePattern::Lit {value: _tmp2.clone()})
 }

-fn parse_simple_pattern_seqof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_seqof<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1575,7 +1632,7 @@ fn parse_simple_pattern_seqof<_Value: preserves::value::NestedValue>(_ctxt: &cra
    Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
 }

-fn parse_simple_pattern_setof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_setof<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1584,7 +1641,7 @@ fn parse_simple_pattern_setof<_Value: preserves::value::NestedValue>(_ctxt: &cra
    Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
 }

-fn parse_simple_pattern_dictof<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_dictof<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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 = ();
@ -1594,13 +1651,14 @@ fn parse_simple_pattern_dictof<_Value: preserves::value::NestedValue>(_ctxt: &cr
    Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
 }

-fn parse_simple_pattern_ref<_Value: preserves::value::NestedValue>(_ctxt: &crate::gen::Language<_Value>, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn parse_simple_pattern_ref<_Value: preserves::value::NestedValue + 'static>(_ctxt: &crate::gen::Language<_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<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for SimplePattern<_Value> {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for SimplePattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        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); }
@ -1614,8 +1672,9 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for SimplePattern<_Value> {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for SimplePattern<_Value> {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        match self {
            SimplePattern::Any => (&_ctxt.LIT_21_ANY).clone(),
@ -1674,8 +1733,9 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language<_Value>, _Value> for Version {
-    fn parse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
+impl<_Value: preserves::value::NestedValue + 'static> _support::Parse<_Value> for Version {
+    type Language = crate::gen::Language<_Value>;
+    fn parse<'a, _LL: Into<&'a Self::Language>>(_ctxt: _LL, value: &_Value)  -> std::result::Result<Self, _support::ParseError> where crate::gen::Language<_Value>: 'a {
        let _ctxt = _ctxt.into();
        if value != &_ctxt.LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); }
        let _tmp0 = ();
@ -1683,6 +1743,11 @@ impl<_Value: preserves::value::NestedValue> _support::Parse<crate::gen::Language
    }
 }

-impl<_Value: preserves::value::NestedValue> _support::Unparse<crate::gen::Language<_Value>, _Value> for Version {
-    fn unparse<'a, _LL: Into<&'a crate::gen::Language<_Value>>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {let _ctxt = _ctxt.into(); let Version = self; (&_ctxt.LIT_28_1).clone()}
+impl<_Value: preserves::value::NestedValue + 'static> _support::Unparse<_Value> for Version {
+    type Language = crate::gen::Language<_Value>;
+    fn unparse<'a, _LL: Into<&'a Self::Language>>(&self, _ctxt: _LL) -> _Value where crate::gen::Language<_Value>: 'a {
+        let _ctxt = _ctxt.into();
+        let Version = self;
+        (&_ctxt.LIT_28_1).clone()
+    }
 }
--- a/implementations/rust/preserves-schema/src/support/mod.rs
+++ b/implementations/rust/preserves-schema/src/support/mod.rs
@ -19,37 +19,57 @@ use std::sync::Arc;

 use thiserror::Error;

-pub trait Parse<L, Value: NestedValue>: Sized {
-    fn parse<'a, LL: Into<&'a L>>(language: LL, value: &Value) -> Result<Self, ParseError> where L: 'a;
+pub trait Parse<Value: NestedValue>: Sized {
+    type Language;
+
+    fn parse<'a, LL: Into<&'a Self::Language>>(language: LL, value: &Value) ->
+        Result<Self, ParseError> where Self::Language: 'a;
 }

-impl<Value: NestedValue> Parse<(), Value> for Value {
-    fn parse<'a, LL: Into<&'a ()>>(_language: LL, value: &Value) -> Result<Self, ParseError> {
+impl<Value: NestedValue> Parse<Value> for Value {
+    type Language = ();
+
+    fn parse<'a, LL: Into<&'a Self::Language>>(_language: LL, value: &Value) ->
+        Result<Self, ParseError> where Self::Language: 'a
+    {
        Ok(value.clone())
    }
 }

-pub trait Unparse<L, Value: NestedValue> {
-    fn unparse<'a, LL: Into<&'a L>>(&self, language: LL) -> Value where L: 'a;
+pub trait Unparse<Value: NestedValue> {
+    type Language;
+
+    fn unparse<'a, LL: Into<&'a Self::Language>>(&self, language: LL) ->
+        Value where Self::Language: 'a;
 }

-impl<Value: NestedValue> Unparse<(), Value> for Value {
-    fn unparse<'a, LL: Into<&'a ()>>(&self, _language: LL) -> Value {
+impl<Value: NestedValue> Unparse<Value> for Value {
+    type Language = ();
+
+    fn unparse<'a, LL: Into<&'a Self::Language>>(&self, _language: LL) ->
+        Value where Self::Language: 'a
+    {
        self.clone()
    }
 }

-pub trait Codec<L, N: NestedValue> {
-    fn parse<T: Parse<L, N>>(&self, value: &N) -> Result<T, ParseError>;
-    fn unparse<T: Unparse<L, N>>(&self, value: &T) -> N;
+pub trait Codec<N: NestedValue, LL> {
+    fn parse<T: Parse<N>>(&self, value: &N) -> Result<T, ParseError>
+    where for<'a> &'a LL: Into<&'a T::Language>;
+    fn unparse<T: Unparse<N>>(&self, value: &T) -> N
+    where for<'a> &'a LL: Into<&'a T::Language>;
 }

-impl<L, N: NestedValue, LL> Codec<L, N> for LL where for<'a> &'a LL: Into<&'a L> {
-    fn parse<T: Parse<L, N>>(&self, value: &N) -> Result<T, ParseError> {
+impl<N: NestedValue + 'static, LL> Codec<N, LL> for LL {
+    fn parse<T: Parse<N>>(&self, value: &N) -> Result<T, ParseError>
+    where for<'a> &'a LL: Into<&'a T::Language>
+    {
        T::parse(self, value)
    }

-    fn unparse<T: Unparse<L, N>>(&self, value: &T) -> N {
+    fn unparse<T: Unparse<N>>(&self, value: &T) -> N
+    where for<'a> &'a LL: Into<&'a T::Language>
+    {
        value.unparse(self)
    }
 }
--- a/implementations/rust/preserves-schema/src/syntax/block.rs
+++ b/implementations/rust/preserves-schema/src/syntax/block.rs
@ -336,6 +336,10 @@ pub mod constructors {
        v.set_vertical_mode(if spaced { VerticalMode::ExtraNewline } else { VerticalMode::Normal });
        v
    }
+
+    pub fn indented(sequence: Sequence) -> Grouping {
+        Grouping { sequence, open: "", close: "" }
+    }
 }

 pub mod macros {