From 69662189fb001a732156ddb2fddb7c1f6537ea2a Mon Sep 17 00:00:00 2001
From: Tony Garnock-Jones <tonyg@leastfixedpoint.com>
Date: Sun, 10 Jul 2022 18:20:12 +0200
Subject: [PATCH] Regenerate schema.rs

---
 .../rust/preserves-schema/src/gen/mod.rs      |   5 +-
 .../rust/preserves-schema/src/gen/schema.rs   | 393 +++++++++++++++---
 2 files changed, 331 insertions(+), 67 deletions(-)

diff --git a/implementations/rust/preserves-schema/src/gen/mod.rs b/implementations/rust/preserves-schema/src/gen/mod.rs
index 7560047..5740cf7 100644
--- a/implementations/rust/preserves-schema/src/gen/mod.rs
+++ b/implementations/rust/preserves-schema/src/gen/mod.rs
@@ -1,10 +1,9 @@
 pub mod schema;
 
 use crate::support as _support;
-use _support::preserves;
 
 #[allow(non_snake_case)]
-pub struct Language<N: preserves::value::NestedValue> {
+pub struct Language<N: _support::preserves::value::NestedValue> {
     pub LIT_15_FALSE: N /* #f */,
     pub LIT_28_1: N /* 1 */,
     pub LIT_0_BOOLEAN: N /* Boolean */,
@@ -36,7 +35,7 @@ pub struct Language<N: preserves::value::NestedValue> {
     pub LIT_20_VERSION: N /* version */
 }
 
-impl<N: preserves::value::NestedValue> Default for Language<N> {
+impl<N: _support::preserves::value::NestedValue> Default for Language<N> {
     fn default() -> Self {
         Language {
             LIT_15_FALSE: /* #f */ _support::decode_lit(&vec![160]).unwrap(),
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index 61b692b..372fd86 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -6,9 +6,8 @@ use crate::support as _support;
 use _support::Deserialize;
 use _support::Parse;
 use _support::Unparse;
-use _support::preserves;
-use preserves::value::Domain;
-use preserves::value::NestedValue;
+use _support::preserves::value::Domain;
+use _support::preserves::value::NestedValue;
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
 pub enum AtomKind {
@@ -23,7 +22,12 @@ pub enum AtomKind {
 
 impl _support::preserves::value::Domain for AtomKind {}
 
-fn read_atom_kind_boolean<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_boolean<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "Boolean" => {}
@@ -35,7 +39,12 @@ fn read_atom_kind_boolean<'de, _Value: _support::preserves::value::NestedValue,
     Ok(AtomKind::Boolean)
 }
 
-fn read_atom_kind_float<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_float<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "Float" => {}
@@ -47,7 +56,12 @@ fn read_atom_kind_float<'de, _Value: _support::preserves::value::NestedValue, _D
     Ok(AtomKind::Float)
 }
 
-fn read_atom_kind_double<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_double<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "Double" => {}
@@ -59,7 +73,12 @@ fn read_atom_kind_double<'de, _Value: _support::preserves::value::NestedValue, _
     Ok(AtomKind::Double)
 }
 
-fn read_atom_kind_signed_integer<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_signed_integer<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
@@ -71,7 +90,12 @@ fn read_atom_kind_signed_integer<'de, _Value: _support::preserves::value::Nested
     Ok(AtomKind::SignedInteger)
 }
 
-fn read_atom_kind_string<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_string<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "String" => {}
@@ -83,7 +107,12 @@ fn read_atom_kind_string<'de, _Value: _support::preserves::value::NestedValue, _
     Ok(AtomKind::String)
 }
 
-fn read_atom_kind_byte_string<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_byte_string<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "ByteString" => {}
@@ -95,7 +124,12 @@ fn read_atom_kind_byte_string<'de, _Value: _support::preserves::value::NestedVal
     Ok(AtomKind::ByteString)
 }
 
-fn read_atom_kind_symbol<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
+fn read_atom_kind_symbol<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<AtomKind, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "Symbol" => {}
@@ -107,7 +141,12 @@ fn read_atom_kind_symbol<'de, _Value: _support::preserves::value::NestedValue, _
     Ok(AtomKind::Symbol)
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for AtomKind {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for AtomKind {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -229,14 +268,21 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Binding<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub struct Binding<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     pub name: std::string::String,
     pub pattern: SimplePattern<_Value>
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Binding<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Binding<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Binding<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -294,13 +340,20 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Bundle<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub struct Bundle<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     pub modules: Modules<_Value>
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Bundle<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Bundle<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Bundle<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -353,7 +406,9 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum CompoundPattern<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum CompoundPattern<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     Rec {
         label: std::boxed::Box<NamedPattern<_Value>>,
         fields: std::boxed::Box<NamedPattern<_Value>>
@@ -372,7 +427,12 @@ pub enum CompoundPattern<_Value: _support::preserves::value::NestedValue = _supp
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for CompoundPattern<_Value> {}
 
-fn read_compound_pattern_rec<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn read_compound_pattern_rec<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -395,7 +455,12 @@ fn read_compound_pattern_rec<'de, _Value: _support::preserves::value::NestedValu
     Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
 }
 
-fn read_compound_pattern_tuple<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn read_compound_pattern_tuple<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -424,7 +489,12 @@ fn read_compound_pattern_tuple<'de, _Value: _support::preserves::value::NestedVa
     Ok(CompoundPattern::Tuple {patterns: _tmp2})
 }
 
-fn read_compound_pattern_tuple_prefix<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn read_compound_pattern_tuple_prefix<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -456,7 +526,12 @@ fn read_compound_pattern_tuple_prefix<'de, _Value: _support::preserves::value::N
     Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
 }
 
-fn read_compound_pattern_dict<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
+fn read_compound_pattern_dict<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<CompoundPattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -476,7 +551,12 @@ fn read_compound_pattern_dict<'de, _Value: _support::preserves::value::NestedVal
     Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for CompoundPattern<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for CompoundPattern<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -617,7 +697,9 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Definition<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum Definition<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     Or {
         pattern_0: std::boxed::Box<NamedAlternative<_Value>>,
         pattern_1: std::boxed::Box<NamedAlternative<_Value>>,
@@ -633,7 +715,12 @@ pub enum Definition<_Value: _support::preserves::value::NestedValue = _support::
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Definition<_Value> {}
 
-fn read_definition_or<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn read_definition_or<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -672,7 +759,12 @@ fn read_definition_or<'de, _Value: _support::preserves::value::NestedValue, _Dec
     })
 }
 
-fn read_definition_and<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn read_definition_and<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -711,12 +803,22 @@ fn read_definition_and<'de, _Value: _support::preserves::value::NestedValue, _De
     })
 }
 
-fn read_definition_pattern<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
+fn read_definition_pattern<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Definition<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::deserialize(r)?;
     Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Definition<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Definition<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -841,11 +943,18 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Definitions<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue>(pub _support::preserves::value::Map<std::string::String, Definition<_Value>>);
+pub struct Definitions<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map<std::string::String, Definition<_Value>>);
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Definitions<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Definitions<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Definitions<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -892,11 +1001,18 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct DictionaryEntries<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue>(pub _support::preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
+pub struct DictionaryEntries<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for DictionaryEntries<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for DictionaryEntries<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for DictionaryEntries<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -950,12 +1066,22 @@ pub enum EmbeddedTypeName {
 
 impl _support::preserves::value::Domain for EmbeddedTypeName {}
 
-fn read_embedded_type_name_ref<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn read_embedded_type_name_ref<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     let _tmp0 = Ref::deserialize(r)?;
     Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_embedded_type_name_false<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
+fn read_embedded_type_name_false<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Boolean(w) if !*w => {}
@@ -967,7 +1093,12 @@ fn read_embedded_type_name_false<'de, _Value: _support::preserves::value::Nested
     Ok(EmbeddedTypeName::False)
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for EmbeddedTypeName {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for EmbeddedTypeName {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -1025,7 +1156,12 @@ pub struct ModulePath(pub std::vec::Vec<std::string::String>);
 
 impl _support::preserves::value::Domain for ModulePath {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for ModulePath {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for ModulePath {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_sequence()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -1075,11 +1211,18 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Modules<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue>(pub _support::preserves::value::Map<ModulePath, Schema<_Value>>);
+pub struct Modules<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map<ModulePath, Schema<_Value>>);
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Modules<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Modules<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Modules<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_dictionary()?;
         let mut _tmp2 = _support::B::Type::default();
@@ -1126,14 +1269,21 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct NamedAlternative<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub struct NamedAlternative<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     pub variant_label: std::string::String,
     pub pattern: Pattern<_Value>
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for NamedAlternative<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for NamedAlternative<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for NamedAlternative<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_sequence()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -1179,24 +1329,41 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedPattern<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum NamedPattern<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     Named(std::boxed::Box<Binding<_Value>>),
     Anonymous(std::boxed::Box<Pattern<_Value>>)
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for NamedPattern<_Value> {}
 
-fn read_named_pattern_named<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
+fn read_named_pattern_named<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::deserialize(r)?;
     Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_named_pattern_anonymous<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
+fn read_named_pattern_anonymous<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedPattern<_Value>, _support::ParseError> {
     let _tmp0 = Pattern::deserialize(r)?;
     Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for NamedPattern<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for NamedPattern<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -1249,24 +1416,41 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedSimplePattern<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum NamedSimplePattern<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     Named(std::boxed::Box<Binding<_Value>>),
     Anonymous(std::boxed::Box<SimplePattern<_Value>>)
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for NamedSimplePattern<_Value> {}
 
-fn read_named_simple_pattern_named<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
+fn read_named_simple_pattern_named<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Binding::deserialize(r)?;
     Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_named_simple_pattern_anonymous<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
+fn read_named_simple_pattern_anonymous<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<NamedSimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::deserialize(r)?;
     Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for NamedSimplePattern<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for NamedSimplePattern<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -1319,24 +1503,41 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Pattern<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum Pattern<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     SimplePattern(std::boxed::Box<SimplePattern<_Value>>),
     CompoundPattern(std::boxed::Box<CompoundPattern<_Value>>)
 }
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Pattern<_Value> {}
 
-fn read_pattern_simple_pattern<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
+fn read_pattern_simple_pattern<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = SimplePattern::deserialize(r)?;
     Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
 }
 
-fn read_pattern_compound_pattern<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
+fn read_pattern_compound_pattern<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Pattern<_Value>, _support::ParseError> {
     let _tmp0 = CompoundPattern::deserialize(r)?;
     Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Pattern<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Pattern<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -1396,7 +1597,12 @@ pub struct Ref {
 
 impl _support::preserves::value::Domain for Ref {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Ref {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Ref {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -1454,7 +1660,9 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Schema<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub struct Schema<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     pub definitions: Definitions<_Value>,
     pub embedded_type: EmbeddedTypeName,
     pub version: Version
@@ -1462,7 +1670,12 @@ pub struct Schema<_Value: _support::preserves::value::NestedValue = _support::pr
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for Schema<_Value> {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Schema<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Schema<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         r.reader.open_record()?;
         let mut _tmp0 = _support::B::Type::default();
@@ -1582,7 +1795,9 @@ impl<
 }
 
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum SimplePattern<_Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue> {
+pub enum SimplePattern<
+    _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
     Any,
     Atom {
         atom_kind: std::boxed::Box<AtomKind>
@@ -1608,7 +1823,12 @@ pub enum SimplePattern<_Value: _support::preserves::value::NestedValue = _suppor
 
 impl<_Value: _support::preserves::value::NestedValue> _support::preserves::value::Domain for SimplePattern<_Value> {}
 
-fn read_simple_pattern_any<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_any<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     match r.next_token()? {
         _support::preserves::value::Token::Atom(v) => match v.value() {
             _support::preserves::value::Value::Symbol(w) if w == "any" => {}
@@ -1620,7 +1840,12 @@ fn read_simple_pattern_any<'de, _Value: _support::preserves::value::NestedValue,
     Ok(SimplePattern::Any)
 }
 
-fn read_simple_pattern_atom<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_atom<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1640,7 +1865,12 @@ fn read_simple_pattern_atom<'de, _Value: _support::preserves::value::NestedValue
     Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_embedded<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_embedded<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1660,7 +1890,12 @@ fn read_simple_pattern_embedded<'de, _Value: _support::preserves::value::NestedV
     Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_lit<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_lit<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1680,7 +1915,12 @@ fn read_simple_pattern_lit<'de, _Value: _support::preserves::value::NestedValue,
     Ok(SimplePattern::Lit {value: _tmp2})
 }
 
-fn read_simple_pattern_seqof<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_seqof<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1700,7 +1940,12 @@ fn read_simple_pattern_seqof<'de, _Value: _support::preserves::value::NestedValu
     Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_setof<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_setof<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1720,7 +1965,12 @@ fn read_simple_pattern_setof<'de, _Value: _support::preserves::value::NestedValu
     Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
 }
 
-fn read_simple_pattern_dictof<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_dictof<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     r.reader.open_record()?;
     let mut _tmp0 = _support::B::Type::default();
     _tmp0.shift(Some(_support::B::Item::RecordLabel));
@@ -1743,12 +1993,22 @@ fn read_simple_pattern_dictof<'de, _Value: _support::preserves::value::NestedVal
     Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
 }
 
-fn read_simple_pattern_ref<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
+fn read_simple_pattern_ref<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<SimplePattern<_Value>, _support::ParseError> {
     let _tmp0 = Ref::deserialize(r)?;
     Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
 }
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for SimplePattern<_Value> {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for SimplePattern<_Value> {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> 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 }
@@ -1928,7 +2188,12 @@ pub struct Version;
 
 impl _support::preserves::value::Domain for Version {}
 
-impl<'de, _Value: _support::preserves::value::NestedValue, _Dec: _support::DomainDecode<_Value::Embedded>, _R: _support::Reader<'de>> _support::Deserialize<'de, _Value, _Dec, _R> for Version {
+impl<
+    'de,
+    _Value: _support::preserves::value::NestedValue,
+    _Dec: _support::DomainDecode<_Value::Embedded>,
+    _R: _support::Reader<'de>
+> _support::Deserialize<'de, _Value, _Dec, _R> for Version {
     fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _Dec, _R>) -> std::result::Result<Self, _support::ParseError> {
         match r.next_token()? {
             _support::preserves::value::Token::Atom(v) => match v.value() {