diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs
index 5ece82c..52c5be3 100644
--- a/implementations/rust/preserves-schema/src/compiler/readers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/readers.rs
@@ -106,7 +106,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
                                         seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"],
                                         seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"],
                                         "_R: _support::Reader<'de>"],
-                                    seq!["(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> "],
+                                    seq!["(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _R, _Dec>) -> "],
                                     "std::result::Result<",
                                     names::render_constructor(n), ty.generic_arg(ctxt.m),
                                     ", _support::ParseError> ",
@@ -143,15 +143,18 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
 
             item(seq![
                 "impl", anglebrackets![
-                    "'de",
-                    seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"],
-                    seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"],
-                    "_R: _support::Reader<'de>"], " ",
-                "_support::Deserialize", anglebrackets!["'de", ctxt.m.any_type(), "_Dec", "_R"], " ",
+                    seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"]], " ",
+                "_support::Deserialize", anglebrackets![ctxt.m.any_type()], " ",
                 "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", codeblock![
-                    seq!["fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> ",
-                         "std::result::Result<Self, _support::ParseError> ",
-                         codeblock(body)]]])
+                    seq![
+                        "fn deserialize",
+                        vertical(false, anglebrackets![
+                            "'de",
+                            seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"],
+                            "_R: _support::Reader<'de>"]),
+                        "(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _R, _Dec>) -> ",
+                        "std::result::Result<Self, _support::ParseError> ",
+                        codeblock(body)]]])
         });
 }
 
diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs
index b6ed6eb..ef181ad 100644
--- a/implementations/rust/preserves-schema/src/compiler/types.rs
+++ b/implementations/rust/preserves-schema/src/compiler/types.rs
@@ -62,9 +62,27 @@ impl compiler::Plugin for TypePlugin {
         if let ModuleContextMode::TargetGeneric = m.mode {
             let ty = definition_type(&m.module_path, n, d);
             m.define_type(item(ty.render(m, n)));
-            m.define_type(item(seq![
-                "impl", ty.generic_decl(m), " _support::preserves::value::Domain for ",
-                names::render_constructor(n), ty.generic_arg(m), " {}"]));
+            if ty.has_embedded(m.bundle) {
+                m.define_type(item(
+                    vertical(false, seq![
+                        seq!["impl<", m.any_type(), "> _support::preserves::value::Domain for ",
+                             names::render_constructor(n), ty.generic_arg(m)],
+                        seq!["where for<'value> ", m.any_type(),
+                             ": _support::preserves::value::NestedValue<Embedded = ",
+                             names::render_constructor(n), ty.generic_arg(m), "> + 'value"],
+                        codeblock![
+                            seq!["type Decode = _support::SchemaDomainCodec<", m.any_type(), ">;"],
+                            seq!["type Encode = _support::SchemaDomainCodec<", m.any_type(), ">;"]
+                        ]])));
+            } else {
+                m.define_type(item(seq![
+                    "impl", ty.generic_decl(m), " _support::preserves::value::Domain for ",
+                    names::render_constructor(n), ty.generic_arg(m), " ",
+                    codeblock![
+                        seq!["type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue<", names::render_constructor(n), ty.generic_arg(m), ">>;"],
+                        seq!["type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue<", names::render_constructor(n), ty.generic_arg(m), ">>;"]
+                    ]]));
+            }
         }
     }
 }
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index d9ff777..3a3b8e6 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -146,10 +146,10 @@ fn read_atom_kind_symbol<
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for AtomKind {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_atom_kind_float(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -278,8 +278,7 @@ pub struct Binding<
 }
 
 impl<_Value> _support::preserves::value::Domain for Binding<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Binding<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Binding<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -287,10 +286,10 @@ where
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Binding<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
         _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -354,20 +353,18 @@ pub struct Bundle<
 }
 
 impl<_Value> _support::preserves::value::Domain for Bundle<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Bundle<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Bundle<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Bundle<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Bundle<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
         _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -439,8 +436,7 @@ pub enum CompoundPattern<
 }
 
 impl<_Value> _support::preserves::value::Domain for CompoundPattern<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = CompoundPattern<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = CompoundPattern<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -570,13 +566,12 @@ fn read_compound_pattern_dict<
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for CompoundPattern<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for CompoundPattern<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_compound_pattern_tuple(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -733,8 +728,7 @@ pub enum Definition<
 }
 
 impl<_Value> _support::preserves::value::Domain for Definition<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Definition<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Definition<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -838,13 +832,12 @@ fn read_definition_pattern<
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Definition<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Definition<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_definition_and(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -973,20 +966,18 @@ pub struct Definitions<
 >(pub _support::preserves::value::Map<std::string::String, Definition<_Value>>);
 
 impl<_Value> _support::preserves::value::Domain for Definitions<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Definitions<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Definitions<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Definitions<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Definitions<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
         let mut _tmp1 = _support::preserves::value::Map::new();
@@ -1037,20 +1028,18 @@ pub struct DictionaryEntries<
 >(pub _support::preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
 
 impl<_Value> _support::preserves::value::Domain for DictionaryEntries<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = DictionaryEntries<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = DictionaryEntries<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for DictionaryEntries<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for DictionaryEntries<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
         let mut _tmp1 = _support::preserves::value::Map::new();
@@ -1135,10 +1124,10 @@ fn read_embedded_type_name_false<
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for EmbeddedTypeName {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -1200,10 +1189,10 @@ impl _support::preserves::value::Domain for ModulePath {
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for ModulePath {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_sequence()?;
         let mut _tmp2 = _support::B::Type::default();
         let mut _tmp1 = std::vec::Vec::new();
@@ -1257,20 +1246,18 @@ pub struct Modules<
 >(pub _support::preserves::value::Map<ModulePath, Schema<_Value>>);
 
 impl<_Value> _support::preserves::value::Domain for Modules<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Modules<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Modules<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Modules<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Modules<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
         let mut _tmp1 = _support::preserves::value::Map::new();
@@ -1324,20 +1311,18 @@ pub struct NamedAlternative<
 }
 
 impl<_Value> _support::preserves::value::Domain for NamedAlternative<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedAlternative<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedAlternative<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for NamedAlternative<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for NamedAlternative<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_sequence()?;
         let mut _tmp0 = _support::B::Type::default();
         _tmp0.shift(Some(_support::B::Item::SequenceValue));
@@ -1390,8 +1375,7 @@ pub enum NamedPattern<
 }
 
 impl<_Value> _support::preserves::value::Domain for NamedPattern<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedPattern<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedPattern<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -1417,13 +1401,12 @@ fn read_named_pattern_anonymous<
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for NamedPattern<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for NamedPattern<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -1483,8 +1466,7 @@ pub enum NamedSimplePattern<
 }
 
 impl<_Value> _support::preserves::value::Domain for NamedSimplePattern<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedSimplePattern<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = NamedSimplePattern<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -1510,13 +1492,12 @@ fn read_named_simple_pattern_anonymous<
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for NamedSimplePattern<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for NamedSimplePattern<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -1576,8 +1557,7 @@ pub enum Pattern<
 }
 
 impl<_Value> _support::preserves::value::Domain for Pattern<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Pattern<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Pattern<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -1603,13 +1583,12 @@ fn read_pattern_compound_pattern<
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Pattern<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Pattern<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -1673,10 +1652,10 @@ impl _support::preserves::value::Domain for Ref {
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Ref {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
         _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1742,20 +1721,18 @@ pub struct Schema<
 }
 
 impl<_Value> _support::preserves::value::Domain for Schema<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Schema<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = Schema<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for Schema<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Schema<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
         _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1901,8 +1878,7 @@ pub enum SimplePattern<
 }
 
 impl<_Value> _support::preserves::value::Domain for SimplePattern<_Value>
-where
-    for<'value> _Value: _support::preserves::value::NestedValue<Embedded = SimplePattern<_Value>> + 'value
+where for<'value> _Value: _support::preserves::value::NestedValue<Embedded = SimplePattern<_Value>> + 'value
 {
     type Decode = _support::SchemaDomainCodec<_Value>;
     type Encode = _support::SchemaDomainCodec<_Value>;
@@ -2088,13 +2064,12 @@ fn read_simple_pattern_ref<
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl<    _Value: _support::preserves::value::NestedValue,
-> _support::Deserialize<_Value> for SimplePattern<_Value> {
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for SimplePattern<_Value> {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         let _mark = r.reader.mark()?;
         match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
         match read_simple_pattern_atom(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
@@ -2278,10 +2253,10 @@ impl _support::preserves::value::Domain for Version {
 
 impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Version {
     fn deserialize<
-    'de,
-    _Dec: _support::DomainDecode<_Value::Embedded>,
-    _R: _support::Reader<'de>
->(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
+        'de,
+        _Dec: _support::DomainDecode<_Value::Embedded>,
+        _R: _support::Reader<'de>
+    >(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result<Self, _support::ParseError> {
         match r.next_token()? {
             _support::preserves::value::Token::Atom(v) => match v.value() {
                 _support::preserves::value::Value::SignedInteger(w) if *w == (1).into() => {}