diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs
index 8fe7336..23f325e 100644
--- a/implementations/rust/preserves-schema/src/compiler/context.rs
+++ b/implementations/rust/preserves-schema/src/compiler/context.rs
@@ -99,7 +99,7 @@ impl<'b> BundleContext<'b> {
             _ => prefix
         };
         let next_id = next_id.to_case(Case::UpperSnake);
-        format!("&_ctxt.{}", self.literals.entry(v.clone()).or_insert(next_id))
+        format!("&_ctxt.into().{}", self.literals.entry(v.clone()).or_insert(next_id))
     }
 
     pub fn generate_module<F: FnOnce(&mut ModuleContext)>(
diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs
index 48e8e4b..5afdb82 100644
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@@ -27,7 +27,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
     m.define_function(
         n,
         |mut ctxt| {
-            let mut body = vec![item("let _ctxt = _ctxt.into();")];
+            let mut body = vec![];
 
             match d {
                 Definition::Or { pattern_0, pattern_1, pattern_n } => {
@@ -43,8 +43,13 @@ 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(),
-                                          "(_ctxt: &", ctxt.m.language_type(), ", value: &", ctxt.m.any_type(), ") -> ",
+
+                                item(seq!["fn ", fname.clone(),
+                                          anglebrackets![
+                                              "'a",
+                                              seq!["_L: Copy + Into<&'a ", ctxt.m.language_type(), ">"],
+                                              seq![ctxt.m.any_type(), ": preserves::value::NestedValue + 'a"]],
+                                          "(_ctxt: _L, value: &", ctxt.m.any_type(), ") -> ",
                                           "std::result::Result<",
                                           names::render_constructor(n), ty.generic_arg(ctxt.m),
                                           ", _support::ParseError> ",
@@ -69,7 +74,7 @@ pub fn gen_definition_parser(m: &mut ModuleContext, n: &str, d: &Definition) {
                 }
             }
 
-            item(seq!["impl<'a, _L: Into<&'a ", ctxt.m.language_type(), ">, ", ctxt.m.any_type(), ": preserves::value::NestedValue + 'a>",
+            item(seq!["impl<'a, _L: Copy + Into<&'a ", ctxt.m.language_type(), ">, ", ctxt.m.any_type(), ": preserves::value::NestedValue + 'a>",
                       " _support::Parse", anglebrackets!["_L", ctxt.m.any_type()], " for ",
                       names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
                       codeblock![
diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
index 922bcd7..16a766e 100644
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@@ -66,7 +66,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
     m.define_function(
         n,
         |mut ctxt| {
-            let mut body = vec![item("let _ctxt = _ctxt.into();")];
+            let mut body = vec![];
 
             match d {
                 Definition::Or { pattern_0, pattern_1, pattern_n } => {
@@ -97,7 +97,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
                 }
             }
 
-            item(seq!["impl<'a, _L: Into<&'a ", ctxt.m.language_type(), ">, ", ctxt.m.any_type(), ": preserves::value::NestedValue + 'a>",
+            item(seq!["impl<'a, _L: Copy + Into<&'a ", ctxt.m.language_type(), ">, ", ctxt.m.any_type(), ": preserves::value::NestedValue + 'a>",
                       " _support::Unparse", anglebrackets!["_L", ctxt.m.any_type()], " for ",
                       names::render_constructor(n), ty.generic_arg(ctxt.m), " ",
                       codeblock![
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index 903ab01..eb03b89 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -121,51 +121,78 @@ 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> {
-    if value != &_ctxt.LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); }
+fn parse_atom_kind_boolean<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); }
+fn parse_atom_kind_float<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); }
+fn parse_atom_kind_double<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); }
+fn parse_atom_kind_signed_integer<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); }
+fn parse_atom_kind_string<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); }
+fn parse_atom_kind_byte_string<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().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> {
-    if value != &_ctxt.LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); }
+fn parse_atom_kind_symbol<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<AtomKind, _support::ParseError> {
+    if value != &_ctxt.into().LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); }
     let _tmp0 = ();
     Ok(AtomKind::Symbol)
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for AtomKind {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for AtomKind {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         if let Ok(r) = parse_atom_kind_double(_ctxt, value) { return Ok(r); }
@@ -177,17 +204,16 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for AtomKind {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for AtomKind {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
-            AtomKind::Boolean => (&_ctxt.LIT_0_BOOLEAN).clone(),
-            AtomKind::Float => (&_ctxt.LIT_1_FLOAT).clone(),
-            AtomKind::Double => (&_ctxt.LIT_2_DOUBLE).clone(),
-            AtomKind::SignedInteger => (&_ctxt.LIT_3_SIGNED_INTEGER).clone(),
-            AtomKind::String => (&_ctxt.LIT_4_STRING).clone(),
-            AtomKind::ByteString => (&_ctxt.LIT_5_BYTE_STRING).clone(),
-            AtomKind::Symbol => (&_ctxt.LIT_6_SYMBOL).clone(),
+            AtomKind::Boolean => (&_ctxt.into().LIT_0_BOOLEAN).clone(),
+            AtomKind::Float => (&_ctxt.into().LIT_1_FLOAT).clone(),
+            AtomKind::Double => (&_ctxt.into().LIT_2_DOUBLE).clone(),
+            AtomKind::SignedInteger => (&_ctxt.into().LIT_3_SIGNED_INTEGER).clone(),
+            AtomKind::String => (&_ctxt.into().LIT_4_STRING).clone(),
+            AtomKind::ByteString => (&_ctxt.into().LIT_5_BYTE_STRING).clone(),
+            AtomKind::Symbol => (&_ctxt.into().LIT_6_SYMBOL).clone(),
         }
     }
 }
@@ -225,11 +251,10 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Binding<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Binding<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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")); }
+        if _tmp0.label() != &_ctxt.into().LIT_7_NAMED { return Err(_support::ParseError::conformance_error("schema.Binding")); }
         let _tmp1 = ();
         if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Binding")); }
         let _tmp2 = (&_tmp0.fields()[0]).value().to_symbol()?;
@@ -238,12 +263,11 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Binding<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Binding<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let Binding {name: _tmp0, pattern: _tmp1} = self;
         {
-            let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_7_NAMED).clone()]);
+            let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.into().LIT_7_NAMED).clone()]);
             _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap());
             _tmp2.fields_vec_mut().push(_tmp1.unparse(_ctxt));
             _tmp2.finish().wrap()
@@ -280,11 +304,10 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Bundle<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Bundle<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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")); }
+        if _tmp0.label() != &_ctxt.into().LIT_8_BUNDLE { return Err(_support::ParseError::conformance_error("schema.Bundle")); }
         let _tmp1 = ();
         if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Bundle")); }
         let _tmp2 = Modules::parse(_ctxt, (&_tmp0.fields()[0]))?;
@@ -292,12 +315,11 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Bundle<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Bundle<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let Bundle {modules: _tmp0} = self;
         {
-            let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_8_BUNDLE).clone()]);
+            let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_8_BUNDLE).clone()]);
             _tmp1.fields_vec_mut().push(_tmp0.unparse(_ctxt));
             _tmp1.finish().wrap()
         }
@@ -439,9 +461,13 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); }
     let _tmp2 = NamedPattern::parse(_ctxt, (&_tmp0.fields()[0]))?;
@@ -449,9 +475,13 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().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()?;
@@ -463,9 +493,13 @@ fn parse_compound_pattern_tuple<_Value: preserves::value::NestedValue>(_ctxt: &c
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().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()?;
@@ -478,18 +512,21 @@ fn parse_compound_pattern_tuple_prefix<_Value: preserves::value::NestedValue>(_c
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); }
     let _tmp2 = DictionaryEntries::parse(_ctxt, (&_tmp0.fields()[0]))?;
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for CompoundPattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for CompoundPattern<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         if let Ok(r) = parse_compound_pattern_tuple_prefix(_ctxt, value) { return Ok(r); }
@@ -498,18 +535,17 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for CompoundPattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for CompoundPattern<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
             CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
-                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_9_REC).clone()]);
+                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.into().LIT_9_REC).clone()]);
                 _tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt));
                 _tmp2.finish().wrap()
             },
             CompoundPattern::Tuple {patterns: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_10_TUPLE).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_10_TUPLE).clone()]);
                 _tmp1.fields_vec_mut().push(
                     {
                         let mut _tmp2 = std::vec::Vec::new();
@@ -522,7 +558,7 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
                 _tmp1.finish().wrap()
             },
             CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => {
-                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_11_TUPLE_PREFIX).clone()]);
+                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.into().LIT_11_TUPLE_PREFIX).clone()]);
                 _tmp2.fields_vec_mut().push(
                     {
                         let mut _tmp3 = std::vec::Vec::new();
@@ -536,7 +572,7 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
                 _tmp2.finish().wrap()
             },
             CompoundPattern::Dict {entries: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_12_DICT).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_12_DICT).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp1.finish().wrap()
             },
@@ -654,9 +690,13 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::or")); }
     let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?;
@@ -675,9 +715,13 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Definition::and")); }
     let _tmp2 = (&_tmp0.fields()[0]).value().to_sequence()?;
@@ -696,14 +740,17 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::parse(_ctxt, value)?;
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Definition<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Definition<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         if let Ok(r) = parse_definition_pattern(_ctxt, value) { return Ok(r); }
@@ -711,12 +758,11 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Definition<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Definition<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         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()]);
+                let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.into().LIT_13_OR).clone()]);
                 _tmp3.fields_vec_mut().push(
                     {
                         let mut _tmp4 = std::vec::Vec::new();
@@ -731,7 +777,7 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
                 _tmp3.finish().wrap()
             },
             Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
-                let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_14_AND).clone()]);
+                let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.into().LIT_14_AND).clone()]);
                 _tmp3.fields_vec_mut().push(
                     {
                         let mut _tmp4 = std::vec::Vec::new();
@@ -774,9 +820,8 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Definitions<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Definitions<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = _tmp1.value().to_symbol()?;
@@ -787,9 +832,8 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Definitions<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Definitions<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        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()
     }
@@ -819,9 +863,8 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for DictionaryEntries<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for DictionaryEntries<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = _tmp1;
@@ -832,9 +875,8 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for DictionaryEntries<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for DictionaryEntries<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let DictionaryEntries(_tmp0) = self;
         preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap()
     }
@@ -874,32 +916,38 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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> {
-    if value != &_ctxt.LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); }
+fn parse_embedded_type_name_false<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+    if value != &_ctxt.into().LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); }
     let _tmp0 = ();
     Ok(EmbeddedTypeName::False)
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for EmbeddedTypeName {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for EmbeddedTypeName {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName"))
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for EmbeddedTypeName {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for EmbeddedTypeName {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
             EmbeddedTypeName::Ref(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
-            EmbeddedTypeName::False => (&_ctxt.LIT_15_FALSE).clone(),
+            EmbeddedTypeName::False => (&_ctxt.into().LIT_15_FALSE).clone(),
         }
     }
 }
@@ -925,9 +973,8 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for ModulePath {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for ModulePath {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
         let _tmp1 = value.value().to_sequence()?;
         let mut _tmp0 = std::vec::Vec::new();
         for _tmp2 in &_tmp1[0..] {
@@ -938,9 +985,8 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for ModulePath {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for ModulePath {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let ModulePath(_tmp0) = self;
         {
             let mut _tmp1 = std::vec::Vec::new();
@@ -976,9 +1022,8 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Modules<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Modules<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
         let mut _tmp0 = preserves::value::Map::new();
         for (_tmp1, _tmp2) in value.value().to_dictionary()? {
             let _tmp3 = ModulePath::parse(_ctxt, _tmp1)?;
@@ -989,9 +1034,8 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Modules<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Modules<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        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()
     }
@@ -1020,9 +1064,8 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedAlternative<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedAlternative<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
         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()?;
@@ -1031,9 +1074,8 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedAlternative<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedAlternative<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = self;
         {
             let mut _tmp2 = std::vec::Vec::new();
@@ -1071,28 +1113,34 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::parse(_ctxt, value)?;
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedPattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedPattern<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         Err(_support::ParseError::conformance_error("schema.NamedPattern"))
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedPattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedPattern<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
             NamedPattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             NamedPattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1127,28 +1175,34 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::parse(_ctxt, value)?;
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedSimplePattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for NamedSimplePattern<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         Err(_support::ParseError::conformance_error("schema.NamedSimplePattern"))
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedSimplePattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for NamedSimplePattern<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
             NamedSimplePattern::Named(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             NamedSimplePattern::Anonymous(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1183,28 +1237,34 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = CompoundPattern::parse(_ctxt, value)?;
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Pattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Pattern<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         Err(_support::ParseError::conformance_error("schema.Pattern"))
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Pattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Pattern<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
             Pattern::SimplePattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
             Pattern::CompoundPattern(_tmp0) => _tmp0.as_ref().unparse(_ctxt),
@@ -1245,11 +1305,10 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Ref {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Ref {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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")); }
+        if _tmp0.label() != &_ctxt.into().LIT_16_REF { return Err(_support::ParseError::conformance_error("schema.Ref")); }
         let _tmp1 = ();
         if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.Ref")); }
         let _tmp2 = ModulePath::parse(_ctxt, (&_tmp0.fields()[0]))?;
@@ -1258,12 +1317,11 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Ref {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Ref {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let Ref {module: _tmp0, name: _tmp1} = self;
         {
-            let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_16_REF).clone()]);
+            let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.into().LIT_16_REF).clone()]);
             _tmp2.fields_vec_mut().push(_tmp0.unparse(_ctxt));
             _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap());
             _tmp2.finish().wrap()
@@ -1338,36 +1396,34 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Schema<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Schema<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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")); }
+        if _tmp0.label() != &_ctxt.into().LIT_17_SCHEMA { return Err(_support::ParseError::conformance_error("schema.Schema")); }
         let _tmp1 = ();
         if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.Schema")); }
         let _tmp2 = (&_tmp0.fields()[0]).value().to_dictionary()?;
-        let _tmp3 = _tmp2.get(&_ctxt.LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
+        let _tmp3 = _tmp2.get(&_ctxt.into().LIT_18_DEFINITIONS).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
         let _tmp4 = Definitions::parse(_ctxt, _tmp3)?;
-        let _tmp5 = _tmp2.get(&_ctxt.LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
+        let _tmp5 = _tmp2.get(&_ctxt.into().LIT_19_EMBEDDED_TYPE).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
         let _tmp6 = EmbeddedTypeName::parse(_ctxt, _tmp5)?;
-        let _tmp7 = _tmp2.get(&_ctxt.LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
+        let _tmp7 = _tmp2.get(&_ctxt.into().LIT_20_VERSION).ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?;
         let _tmp8 = Version::parse(_ctxt, _tmp7)?;
         Ok(Schema {definitions: _tmp4, embedded_type: _tmp6, version: _tmp8})
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Schema<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Schema<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = self;
         {
-            let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.LIT_17_SCHEMA).clone()]);
+            let mut _tmp3 = preserves::value::Record(vec![(&_ctxt.into().LIT_17_SCHEMA).clone()]);
             _tmp3.fields_vec_mut().push(
                 {
                     let mut _tmp4 = preserves::value::Map::new();
-                    _tmp4.insert((&_ctxt.LIT_18_DEFINITIONS).clone(), _tmp0.unparse(_ctxt));
-                    _tmp4.insert((&_ctxt.LIT_19_EMBEDDED_TYPE).clone(), _tmp1.unparse(_ctxt));
-                    _tmp4.insert((&_ctxt.LIT_20_VERSION).clone(), _tmp2.unparse(_ctxt));
+                    _tmp4.insert((&_ctxt.into().LIT_18_DEFINITIONS).clone(), _tmp0.unparse(_ctxt));
+                    _tmp4.insert((&_ctxt.into().LIT_19_EMBEDDED_TYPE).clone(), _tmp1.unparse(_ctxt));
+                    _tmp4.insert((&_ctxt.into().LIT_20_VERSION).clone(), _tmp2.unparse(_ctxt));
                     preserves::value::Value::Dictionary(_tmp4).wrap()
                 }
             );
@@ -1558,60 +1614,88 @@ 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> {
-    if value != &_ctxt.LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); }
+fn parse_simple_pattern_any<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+    if value != &_ctxt.into().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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); }
     let _tmp2 = AtomKind::parse(_ctxt, (&_tmp0.fields()[0]))?;
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); }
     let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?;
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); }
     let _tmp2 = (&_tmp0.fields()[0]);
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); }
     let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?;
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 1 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); }
     let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?;
     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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, 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")); }
+    if _tmp0.label() != &_ctxt.into().LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); }
     let _tmp1 = ();
     if _tmp0.fields().len() < 2 { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); }
     let _tmp2 = SimplePattern::parse(_ctxt, (&_tmp0.fields()[0]))?;
@@ -1619,14 +1703,17 @@ 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<
+    'a,
+    _L: Copy + Into<&'a crate::gen::Language<_Value>>,
+    _Value: preserves::value::NestedValue + 'a
+>(_ctxt: _L, value: &_Value) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Ref::parse(_ctxt, value)?;
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for SimplePattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for SimplePattern<_Value> {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        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); }
         if let Ok(r) = parse_simple_pattern_embedded(_ctxt, value) { return Ok(r); }
@@ -1639,38 +1726,37 @@ impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::N
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for SimplePattern<_Value> {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for SimplePattern<_Value> {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         match self {
-            SimplePattern::Any => (&_ctxt.LIT_21_ANY).clone(),
+            SimplePattern::Any => (&_ctxt.into().LIT_21_ANY).clone(),
             SimplePattern::Atom {atom_kind: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_22_ATOM).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_22_ATOM).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Embedded {interface: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_23_EMBEDDED).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_23_EMBEDDED).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Lit {value: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_24_LIT).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_24_LIT).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.clone());
                 _tmp1.finish().wrap()
             },
             SimplePattern::Seqof {pattern: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_25_SEQOF).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_25_SEQOF).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Setof {pattern: _tmp0} => {
-                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.LIT_26_SETOF).clone()]);
+                let mut _tmp1 = preserves::value::Record(vec![(&_ctxt.into().LIT_26_SETOF).clone()]);
                 _tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp1.finish().wrap()
             },
             SimplePattern::Dictof {key: _tmp0, value: _tmp1} => {
-                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.LIT_27_DICTOF).clone()]);
+                let mut _tmp2 = preserves::value::Record(vec![(&_ctxt.into().LIT_27_DICTOF).clone()]);
                 _tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
                 _tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt));
                 _tmp2.finish().wrap()
@@ -1699,19 +1785,17 @@ impl<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Version {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Parse<_L, _Value> for Version {
     fn parse(_ctxt: _L, value: &_Value) -> std::result::Result<Self, _support::ParseError> {
-        let _ctxt = _ctxt.into();
-        if value != &_ctxt.LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); }
+        if value != &_ctxt.into().LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); }
         let _tmp0 = ();
         Ok(Version)
     }
 }
 
-impl<'a, _L: Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Version {
+impl<'a, _L: Copy + Into<&'a crate::gen::Language<_Value>>, _Value: preserves::value::NestedValue + 'a> _support::Unparse<_L, _Value> for Version {
     fn unparse(&self, _ctxt: _L) -> _Value {
-        let _ctxt = _ctxt.into();
         let Version = self;
-        (&_ctxt.LIT_28_1).clone()
+        (&_ctxt.into().LIT_28_1).clone()
     }
 }