From 8127033407d687eb2fb38e27869a23ce93aca31b Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Tue, 14 Sep 2021 22:45:12 +0200 Subject: [PATCH] Surprisingly, associated types might simplify drastically! --- .../preserves-schema/src/compiler/readers.rs | 6 +- .../rust/preserves-schema/src/gen/schema.rs | 96 +++---- .../rust/preserves-schema/src/support/mod.rs | 7 +- implementations/rust/preserves/src/de.rs | 22 +- implementations/rust/preserves/src/lib.rs | 6 +- .../rust/preserves/src/value/merge.rs | 7 +- .../rust/preserves/src/value/packed/mod.rs | 6 +- .../rust/preserves/src/value/packed/reader.rs | 21 +- .../rust/preserves/src/value/packed/writer.rs | 3 +- .../rust/preserves/src/value/reader.rs | 45 ++-- .../rust/preserves/src/value/repr.rs | 240 +++++++++--------- .../rust/preserves/src/value/text/mod.rs | 6 +- .../rust/preserves/src/value/text/reader.rs | 70 ++--- .../rust/preserves/src/value/text/writer.rs | 3 +- .../rust/preserves/src/value/writer.rs | 8 +- 15 files changed, 273 insertions(+), 273 deletions(-) diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs index d251f3c..cf02c71 100644 --- a/implementations/rust/preserves-schema/src/compiler/readers.rs +++ b/implementations/rust/preserves-schema/src/compiler/readers.rs @@ -97,7 +97,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { item(seq![ "fn ", fname.clone(), anglebrackets![ "'de", - "R: _support::Reader<'de, _Ptr, _Any>"], + "R: _support::Reader<'de, _Any>"], "(r: &mut R) -> ", "std::result::Result<", names::render_constructor(n), ", _support::ParseError> ", block(body)]) @@ -132,8 +132,8 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) { } item(seq![ - "impl", anglebrackets!["'de", "R: _support::Reader<'de, _Ptr, _Any>"], " ", - "_support::Deserialize", anglebrackets!["'de", "_Ptr", "_Any", "R"], " ", + "impl", anglebrackets!["'de", "R: _support::Reader<'de, _Any>"], " ", + "_support::Deserialize", anglebrackets!["'de", "_Any", "R"], " ", "for ", names::render_constructor(n), " ", block![ seq!["fn deserialize(r: &mut R) -> ", "std::result::Result ", diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs index fdecc81..3212449 100644 --- a/implementations/rust/preserves-schema/src/gen/schema.rs +++ b/implementations/rust/preserves-schema/src/gen/schema.rs @@ -174,7 +174,7 @@ pub struct Version; impl preserves::value::Domain for Version {} -fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Boolean" => {} @@ -186,7 +186,7 @@ fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) Ok(AtomKind::Boolean) } -fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_float<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Float" => {} @@ -198,7 +198,7 @@ fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> Ok(AtomKind::Float) } -fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_double<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Double" => {} @@ -210,7 +210,7 @@ fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) - Ok(AtomKind::Double) } -fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "SignedInteger" => {} @@ -222,7 +222,7 @@ fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: & Ok(AtomKind::SignedInteger) } -fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "String" => {} @@ -234,7 +234,7 @@ fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) - Ok(AtomKind::String) } -fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "ByteString" => {} @@ -246,7 +246,7 @@ fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(AtomKind::ByteString) } -fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "Symbol" => {} @@ -258,7 +258,7 @@ fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) - Ok(AtomKind::Symbol) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for AtomKind { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for AtomKind { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -342,7 +342,7 @@ impl std::convert::From<&AtomKind> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Binding { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Binding { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -392,7 +392,7 @@ impl std::convert::From<&Binding> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Bundle { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Bundle { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -437,7 +437,7 @@ impl std::convert::From<&Bundle> for _Any { } } -fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -460,7 +460,7 @@ fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)}) } -fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -489,7 +489,7 @@ fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mu Ok(CompoundPattern::Tuple {patterns: _tmp2}) } -fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -521,7 +521,7 @@ fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _Any>> Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)}) } -fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -541,7 +541,7 @@ fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)}) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for CompoundPattern { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for CompoundPattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -646,7 +646,7 @@ impl std::convert::From<&CompoundPattern> for _Any { } } -fn read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_definition_or<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -685,7 +685,7 @@ fn read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> s }) } -fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_definition_and<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -724,12 +724,12 @@ fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> }) } -fn read_definition_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_definition_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Pattern::deserialize(r)?; Ok(Definition::Pattern(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definition { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definition { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -824,7 +824,7 @@ impl std::convert::From<&Definition> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definitions { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Definitions { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -863,7 +863,7 @@ impl std::convert::From<&Definitions> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for DictionaryEntries { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for DictionaryEntries { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -902,12 +902,12 @@ impl std::convert::From<&DictionaryEntries> for _Any { } } -fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Ref::deserialize(r)?; Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0))) } -fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Boolean(w) if !*w => {} @@ -919,7 +919,7 @@ fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: & Ok(EmbeddedTypeName::False) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for EmbeddedTypeName { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for EmbeddedTypeName { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -957,7 +957,7 @@ impl std::convert::From<&EmbeddedTypeName> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for ModulePath { fn deserialize(r: &mut R) -> std::result::Result { r.open_sequence()?; let mut _tmp2 = _support::B::Type::default(); @@ -994,7 +994,7 @@ impl std::convert::From<&ModulePath> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Modules { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Modules { fn deserialize(r: &mut R) -> std::result::Result { r.open_dictionary()?; let mut _tmp2 = _support::B::Type::default(); @@ -1033,7 +1033,7 @@ impl std::convert::From<&Modules> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedAlternative { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedAlternative { fn deserialize(r: &mut R) -> std::result::Result { r.open_sequence()?; let mut _tmp0 = _support::B::Type::default(); @@ -1071,17 +1071,17 @@ impl std::convert::From<&NamedAlternative> for _Any { } } -fn read_named_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_pattern_named<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Binding::deserialize(r)?; Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0))) } -fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Pattern::deserialize(r)?; Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedPattern { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedPattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1118,17 +1118,17 @@ impl std::convert::From<&NamedPattern> for _Any { } } -fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Binding::deserialize(r)?; Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0))) } -fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = SimplePattern::deserialize(r)?; Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedSimplePattern { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for NamedSimplePattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1165,17 +1165,17 @@ impl std::convert::From<&NamedSimplePattern> for _Any { } } -fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = SimplePattern::deserialize(r)?; Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0))) } -fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = CompoundPattern::deserialize(r)?; Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Pattern { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Pattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1212,7 +1212,7 @@ impl std::convert::From<&Pattern> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Ref { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Ref { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -1262,7 +1262,7 @@ impl std::convert::From<&Ref> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Schema { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Schema { fn deserialize(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); @@ -1357,7 +1357,7 @@ impl std::convert::From<&Schema> for _Any { } } -fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { preserves::value::Value::Symbol(w) if w == "any" => {} @@ -1369,7 +1369,7 @@ fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) Ok(SimplePattern::Any) } -fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1389,7 +1389,7 @@ fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1409,7 +1409,7 @@ fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1429,7 +1429,7 @@ fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) Ok(SimplePattern::Lit {value: _tmp2}) } -fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1449,7 +1449,7 @@ fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1469,7 +1469,7 @@ fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)}) } -fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { r.open_record(None)?; let mut _tmp0 = _support::B::Type::default(); _tmp0.shift(Some(_support::B::Item::RecordLabel)); @@ -1492,12 +1492,12 @@ fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)}) } -fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result { +fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Any>>(r: &mut R) -> std::result::Result { let _tmp0 = Ref::deserialize(r)?; Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0))) } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for SimplePattern { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for SimplePattern { fn deserialize(r: &mut R) -> std::result::Result { let _mark = r.mark()?; match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result } @@ -1633,7 +1633,7 @@ impl std::convert::From<&SimplePattern> for _Any { } } -impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Version { +impl<'de, R: _support::Reader<'de, _Any>> _support::Deserialize<'de, _Any, R> for Version { fn deserialize(r: &mut R) -> std::result::Result { match r.next_token(true)? { preserves::value::Token::Atom(v) => match v.value() { diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs index 6b3ca15..21fd398 100644 --- a/implementations/rust/preserves-schema/src/support/mod.rs +++ b/implementations/rust/preserves-schema/src/support/mod.rs @@ -6,7 +6,6 @@ pub use preserves::value::boundary as B; use preserves::value::ArcValue; use preserves::value::Domain; -use preserves::value::Embeddable; use preserves::value::IOValue; use preserves::value::NestedValue; use preserves::value::NoEmbeddedDomainCodec; @@ -19,14 +18,14 @@ use std::sync::Arc; use thiserror::Error; -pub trait Deserialize<'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> +pub trait Deserialize<'de, N: NestedValue, R: Reader<'de, N>> where Self: Sized { fn deserialize(r: &mut R) -> Result; } -pub fn decode_lit>(bs: &[u8]) -> io::Result { +pub fn decode_lit(bs: &[u8]) -> io::Result { preserves::value::packed::from_bytes(bs, NoEmbeddedDomainCodec) } @@ -45,7 +44,7 @@ pub fn encode_embedded( where for<'a> IOValue: From<&'a D> { - v.copy_via::<_, _, _, std::convert::Infallible>( + v.copy_via::<_, _, std::convert::Infallible>( &mut |d| Ok(Value::Embedded(IOValue::from(d)))).unwrap() } diff --git a/implementations/rust/preserves/src/de.rs b/implementations/rust/preserves/src/de.rs index 4140168..b6abd83 100644 --- a/implementations/rust/preserves/src/de.rs +++ b/implementations/rust/preserves/src/de.rs @@ -13,7 +13,7 @@ pub use super::error::Error; pub type Result = std::result::Result; -pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue, IOValue>> { +pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue>> { pub read: &'r mut R, phantom: PhantomData<&'de ()>, } @@ -39,7 +39,7 @@ where from_reader(&mut PackedReader::new(&mut IOBinarySource::new(read), IOValueDomainCodec)) } -pub fn from_reader<'r, 'de, R: Reader<'de, IOValue, IOValue>, T>(read: &'r mut R) -> +pub fn from_reader<'r, 'de, R: Reader<'de, IOValue>, T>(read: &'r mut R) -> Result where T: Deserialize<'de> @@ -49,13 +49,15 @@ where Ok(t) } -impl<'r, 'de, R: Reader<'de, IOValue, IOValue>> Deserializer<'de, 'r, R> { +impl<'r, 'de, R: Reader<'de, IOValue>> Deserializer<'de, 'r, R> { pub fn from_reader(read: &'r mut R) -> Self { Deserializer { read, phantom: PhantomData } } } -impl<'r, 'de, 'a, R: Reader<'de, IOValue, IOValue>> serde::de::Deserializer<'de> for &'a mut Deserializer<'de, 'r, R> +impl<'r, 'de, 'a, R: Reader<'de, IOValue>> + serde::de::Deserializer<'de> + for &'a mut Deserializer<'de, 'r, R> { type Error = Error; @@ -266,13 +268,13 @@ impl<'r, 'de, 'a, R: Reader<'de, IOValue, IOValue>> serde::de::Deserializer<'de> } } -pub struct Seq<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> { +pub struct Seq<'de, 'r, 'a, R: Reader<'de, IOValue>> { b: B::Type, i: B::Item, de: &'a mut Deserializer<'de, 'r, R>, } -impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> Seq<'de, 'r, 'a, R> { +impl<'de, 'r, 'a, R: Reader<'de, IOValue>> Seq<'de, 'r, 'a, R> { fn new(de: &'a mut Deserializer<'de, 'r, R>, b: B::Type, i: B::Item) -> Self { Seq { b, i, de } } @@ -294,7 +296,7 @@ impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> Seq<'de, 'r, 'a, R> { } } -impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> { +impl<'de, 'r, 'a, R: Reader<'de, IOValue>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> @@ -304,7 +306,7 @@ impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> SeqAccess<'de> for Seq<'de, } } -impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> MapAccess<'de> for Seq<'de, 'r, 'a, R> { +impl<'de, 'r, 'a, R: Reader<'de, IOValue>> MapAccess<'de> for Seq<'de, 'r, 'a, R> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> @@ -325,7 +327,7 @@ impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> MapAccess<'de> for Seq<'de, } } -impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> { +impl<'de, 'r, 'a, R: Reader<'de, IOValue>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> { type Error = Error; type Variant = Seq<'de, 'r, 'a, R>; @@ -338,7 +340,7 @@ impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> EnumAccess<'de> for &'a mut } } -impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> { +impl<'de, 'r, 'a, R: Reader<'de, IOValue>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> { type Error = Error; fn unit_variant(mut self) -> Result<()> { diff --git a/implementations/rust/preserves/src/lib.rs b/implementations/rust/preserves/src/lib.rs index 8d65a80..fa305b3 100644 --- a/implementations/rust/preserves/src/lib.rs +++ b/implementations/rust/preserves/src/lib.rs @@ -51,8 +51,8 @@ mod ieee754_section_5_10_total_order_tests { use super::dom::Dom; use crate::value::{Value, PlainValue}; - fn f(val: f32) -> Value, Dom> { Value::from(val) } - fn d(val: f64) -> Value, Dom> { Value::from(val) } + fn f(val: f32) -> Value> { Value::from(val) } + fn d(val: f64) -> Value> { Value::from(val) } // TODO: Test cases with a few different signalling and non-signalling NaNs @@ -145,7 +145,7 @@ mod value_tests { use crate::value::{Value, PlainValue, repr::Record, signed_integer::SignedInteger}; use super::dom::Dom; - type VV = Value, Dom>; + type VV = Value>; #[test] fn boolean_mut() { let mut b = VV::Boolean(true); diff --git a/implementations/rust/preserves/src/value/merge.rs b/implementations/rust/preserves/src/value/merge.rs index 8e5a3dd..2dd6b0d 100644 --- a/implementations/rust/preserves/src/value/merge.rs +++ b/implementations/rust/preserves/src/value/merge.rs @@ -1,10 +1,9 @@ -use super::Embeddable; use super::Map; use super::NestedValue; use super::Record; use super::Value; -pub fn merge_seqs, D: Embeddable>(mut a: Vec, mut b: Vec) -> Option> { +pub fn merge_seqs(mut a: Vec, mut b: Vec) -> Option> { if a.len() > b.len() { std::mem::swap(&mut a, &mut b); } @@ -17,7 +16,7 @@ pub fn merge_seqs, D: Embeddable>(mut a: Vec, mut b: Vec Some(r) } -pub fn merge2, D: Embeddable>(v: N, w: N) -> Option { +pub fn merge2(v: N, w: N) -> Option { let (mut v_anns, v_val) = v.pieces(); let (w_anns, w_val) = w.pieces(); v_anns.modify(|anns| anns.extend(w_anns.to_vec().into_iter())); @@ -49,7 +48,7 @@ pub fn merge2, D: Embeddable>(v: N, w: N) -> Option { } } -pub fn merge, D: Embeddable, I: IntoIterator>(vs: I) -> Option { +pub fn merge>(vs: I) -> Option { let mut vs = vs.into_iter(); let mut v = vs.next().expect("at least one value in merge()"); for w in vs { diff --git a/implementations/rust/preserves/src/value/packed/mod.rs b/implementations/rust/preserves/src/value/packed/mod.rs index 2620632..0417aac 100644 --- a/implementations/rust/preserves/src/value/packed/mod.rs +++ b/implementations/rust/preserves/src/value/packed/mod.rs @@ -7,9 +7,9 @@ pub use writer::PackedWriter; use std::io; -use super::{BinarySource, DomainDecode, Embeddable, IOValue, IOValueDomainCodec, NestedValue, Reader}; +use super::{BinarySource, DomainDecode, IOValue, IOValueDomainCodec, NestedValue, Reader}; -pub fn from_bytes, Dec: DomainDecode>( +pub fn from_bytes>( bs: &[u8], decode_embedded: Dec, ) -> io::Result { @@ -20,7 +20,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result { from_bytes(bs, IOValueDomainCodec) } -pub fn annotated_from_bytes, Dec: DomainDecode>( +pub fn annotated_from_bytes>( bs: &[u8], decode_embedded: Dec, ) -> io::Result { diff --git a/implementations/rust/preserves/src/value/packed/reader.rs b/implementations/rust/preserves/src/value/packed/reader.rs index 7491029..2b1efb8 100644 --- a/implementations/rust/preserves/src/value/packed/reader.rs +++ b/implementations/rust/preserves/src/value/packed/reader.rs @@ -13,7 +13,6 @@ use super::constants::Tag; use super::super::{ CompoundClass, DomainDecode, - Embeddable, Map, NestedValue, Record, @@ -31,15 +30,15 @@ use super::super::{ signed_integer::SignedInteger, }; -pub struct PackedReader<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> { +pub struct PackedReader<'de, 'src, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> { pub source: &'src mut S, pub decode_embedded: Dec, - phantom: PhantomData<&'de (D, N)>, + phantom: PhantomData<&'de N>, } -impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> +impl<'de, 'src, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> BinarySource<'de> - for PackedReader<'de, 'src, D, N, Dec, S> + for PackedReader<'de, 'src, N, Dec, S> { type Mark = S::Mark; fn mark(&mut self) -> io::Result { @@ -66,7 +65,7 @@ fn out_of_range>(i: I) -> error::Error { error::Error::NumberOutOfRange(i.into()) } -impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> PackedReader<'de, 'src, D, N, Dec, S> { +impl<'de, 'src, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> PackedReader<'de, 'src, N, Dec, S> { pub fn new(source: &'src mut S, decode_embedded: Dec) -> Self { PackedReader { source, decode_embedded, phantom: PhantomData } } @@ -258,9 +257,9 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: Binar } } -impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> - Reader<'de, D, N> - for PackedReader<'de, 'src, D, N, Dec, S> +impl<'de, 'src, N: NestedValue, Dec: DomainDecode, S: BinarySource<'de>> + Reader<'de, N> + for PackedReader<'de, 'src, N, Dec, S> { fn next(&mut self, read_annotations: bool) -> io::Result> { match self.peek() { @@ -415,7 +414,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: Binar self.source.restore(mark) } - fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { + fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { loop { return Ok(match Tag::try_from(self.peek()?)? { Tag::Embedded => { @@ -452,7 +451,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainDecode, S: Binar } } - fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { + fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { match Tag::try_from(self.peek()?)? { Tag::Annotation => { self.skip()?; diff --git a/implementations/rust/preserves/src/value/packed/writer.rs b/implementations/rust/preserves/src/value/packed/writer.rs index 810a529..c656570 100644 --- a/implementations/rust/preserves/src/value/packed/writer.rs +++ b/implementations/rust/preserves/src/value/packed/writer.rs @@ -5,7 +5,6 @@ use std::io; use std::ops::DerefMut; use super::constants::Tag; use super::super::DomainEncode; -use super::super::Embeddable; use super::super::IOValue; use super::super::IOValueDomainCodec; use super::super::NestedValue; @@ -17,7 +16,7 @@ use super::super::writer::{Writer, CompoundWriter, varint}; pub struct PackedWriter(Suspendable); impl PackedWriter<&mut Vec> { - pub fn encode, Enc: DomainEncode>( + pub fn encode>( enc: &mut Enc, v: &N, ) -> io::Result> { diff --git a/implementations/rust/preserves/src/value/reader.rs b/implementations/rust/preserves/src/value/reader.rs index 51c2271..9940288 100644 --- a/implementations/rust/preserves/src/value/reader.rs +++ b/implementations/rust/preserves/src/value/reader.rs @@ -8,7 +8,6 @@ use super::CompoundClass; use super::DomainDecode; use super::DomainParse; use super::Double; -use super::Embeddable; use super::Float; use super::IOValue; use super::IOValueDomainCodec; @@ -19,14 +18,14 @@ use super::signed_integer::SignedInteger; pub type ReaderResult = std::result::Result; -pub enum Token> { - Embedded(D), +pub enum Token { + Embedded(N::D), Atom(N), Compound(CompoundClass), End, } -pub trait Reader<'de, D: Embeddable, N: NestedValue> { +pub trait Reader<'de, N: NestedValue> { fn next(&mut self, read_annotations: bool) -> io::Result>; fn open_record(&mut self, arity: Option) -> ReaderResult; fn open_sequence_or_set(&mut self) -> ReaderResult; @@ -45,8 +44,8 @@ pub trait Reader<'de, D: Embeddable, N: NestedValue> { fn mark(&mut self) -> io::Result; fn restore(&mut self, mark: &Self::Mark) -> io::Result<()>; - fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result>; - fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)>; + fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result>; + fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)>; //--------------------------------------------------------------------------- @@ -131,7 +130,7 @@ pub trait Reader<'de, D: Embeddable, N: NestedValue> { } } - fn configured(self, read_annotations: bool) -> ConfiguredReader<'de, D, N, Self> + fn configured(self, read_annotations: bool) -> ConfiguredReader<'de, N, Self> where Self: std::marker::Sized { @@ -159,10 +158,7 @@ pub trait Reader<'de, D: Embeddable, N: NestedValue> { } } -impl<'r, 'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> - Reader<'de, D, N> - for &'r mut R -{ +impl<'r, 'de, N: NestedValue, R: Reader<'de, N>> Reader<'de, N> for &'r mut R { fn next(&mut self, read_annotations: bool) -> io::Result> { (*self).next(read_annotations) } @@ -213,11 +209,11 @@ impl<'r, 'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> (*self).restore(mark) } - fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { + fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { (*self).next_token(read_embedded_annotations) } - fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { + fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { (*self).next_annotations_and_token() } } @@ -233,30 +229,30 @@ pub trait BinarySource<'de>: Sized { fn readbytes(&mut self, count: usize) -> io::Result>; fn readbytes_into(&mut self, bs: &mut [u8]) -> io::Result<()>; - fn packed, Dec: DomainDecode>( + fn packed>( &mut self, decode_embedded: Dec, - ) -> super::PackedReader<'de, '_, D, N, Dec, Self> { + ) -> super::PackedReader<'de, '_, N, Dec, Self> { super::PackedReader::new(self, decode_embedded) } fn packed_iovalues(&mut self) -> - super::PackedReader<'de, '_, IOValue, IOValue, IOValueDomainCodec, Self> + super::PackedReader<'de, '_, IOValue, IOValueDomainCodec, Self> { self.packed(IOValueDomainCodec) } - fn text, Dec: DomainParse>( + fn text>( &mut self, decode_embedded: Dec, - ) -> super::TextReader<'de, '_, D, Dec, Self> { + ) -> super::TextReader<'de, '_, N::D, Dec, Self> { super::TextReader::new(self, decode_embedded) } fn text_iovalues(&mut self) -> super::TextReader<'de, '_, IOValue, ViaCodec, Self> { - self.text::<_, IOValue, _>(ViaCodec::new(IOValueDomainCodec)) + self.text::(ViaCodec::new(IOValueDomainCodec)) } } @@ -379,13 +375,13 @@ impl<'de> BinarySource<'de> for BytesBinarySource<'de> { } } -pub struct ConfiguredReader<'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> { +pub struct ConfiguredReader<'de, N: NestedValue, R: Reader<'de, N>> { pub reader: R, pub read_annotations: bool, - phantom: PhantomData<&'de (D, N)>, + phantom: PhantomData<&'de N>, } -impl<'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> ConfiguredReader<'de, D, N, R> { +impl<'de, N: NestedValue, R: Reader<'de, N>> ConfiguredReader<'de, N, R> { pub fn new(reader: R) -> Self { reader.configured(true) } @@ -399,10 +395,7 @@ impl<'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> ConfiguredRead } } -impl<'de, D: Embeddable, N: NestedValue, R: Reader<'de, D, N>> - std::iter::Iterator - for ConfiguredReader<'de, D, N, R> -{ +impl<'de, N: NestedValue, R: Reader<'de, N>> std::iter::Iterator for ConfiguredReader<'de, N, R> { type Item = io::Result; fn next(&mut self) -> Option { match self.reader.next(self.read_annotations) { diff --git a/implementations/rust/preserves/src/value/repr.rs b/implementations/rust/preserves/src/value/repr.rs index a92d989..baeac36 100644 --- a/implementations/rust/preserves/src/value/repr.rs +++ b/implementations/rust/preserves/src/value/repr.rs @@ -7,7 +7,6 @@ use std::convert::TryFrom; use std::convert::TryInto; use std::fmt::Debug; use std::hash::{Hash, Hasher}; -use std::marker::PhantomData; use std::ops::Index; use std::ops::IndexMut; use std::string::String; @@ -26,12 +25,14 @@ impl Embeddable for T where T: Domain + Clone {} impl Domain for Arc {} -pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { - fn new(v: V) -> Self where Value: From { +pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { + type D: Embeddable; + + fn new(v: V) -> Self where Value: From { Value::from(v).wrap() } - fn domain(e: E) -> Self where D: From { + fn domain(e: E) -> Self where Self::D: From { Value::Embedded(e.into()).wrap() } @@ -43,12 +44,12 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { Value::bytestring(v).wrap() } - fn wrap(anns: Annotations, v: Value) -> Self; + fn wrap(anns: Annotations, v: Value) -> Self; - fn annotations(&self) -> &Annotations; - fn value(&self) -> &Value; - fn pieces(self) -> (Annotations, Value); - fn value_owned(self) -> Value; + fn annotations(&self) -> &Annotations; + fn value(&self) -> &Value; + fn pieces(self) -> (Annotations, Value); + fn value_owned(self) -> Value; fn value_class(&self) -> ValueClass { self.value().value_class() @@ -61,16 +62,16 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { self.value().fmt(f) } - fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result + fn copy_via(&self, f: &mut F) -> Result where - F: FnMut(&D) -> Result, Err> + F: FnMut(&Self::D) -> Result, Err> { Ok(M::wrap(self.annotations().copy_via(f)?, self.value().copy_via(f)?)) } fn foreach_embedded(&self, f: &mut F) -> Result<(), Err> where - F: FnMut(&D) -> Result<(), Err> + F: FnMut(&Self::D) -> Result<(), Err> { match &self.annotations().0 { None => (), @@ -82,7 +83,7 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { /// The `Value`s from the specification. #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub enum Value where N: NestedValue, D: Embeddable { +pub enum Value { Boolean(bool), Float(Float), Double(Double), @@ -94,7 +95,7 @@ pub enum Value where N: NestedValue, D: Embeddable { Sequence(Vec), Set(Set), Dictionary(Map), - Embedded(D), + Embedded(N::D), } /// The kinds of `Value` from the specification. @@ -167,7 +168,7 @@ impl Record { &mut self.0 } - pub fn finish(self) -> Value where N: NestedValue { + pub fn finish(self) -> Value where N: NestedValue { Value::Record(self) } } @@ -256,44 +257,44 @@ impl PartialOrd for Double { impl Eq for Double {} -impl, D: Embeddable> From for Value { fn from(v: bool) -> Self { Value::Boolean(v) } } -impl, D: Embeddable> From<&bool> for Value { fn from(v: &bool) -> Self { Value::Boolean(*v) } } +impl From for Value { fn from(v: bool) -> Self { Value::Boolean(v) } } +impl From<&bool> for Value { fn from(v: &bool) -> Self { Value::Boolean(*v) } } -impl, D: Embeddable> From for Value { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } } -impl, D: Embeddable> From<&f32> for Value { fn from(v: &f32) -> Self { Value::Float(Float::from(*v)) } } -impl, D: Embeddable> From<&Float> for Value { fn from(v: &Float) -> Self { Value::Float(v.clone()) } } -impl, D: Embeddable> From for Value { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } } -impl, D: Embeddable> From<&f64> for Value { fn from(v: &f64) -> Self { Value::Double(Double::from(*v)) } } -impl, D: Embeddable> From<&Double> for Value { fn from(v: &Double) -> Self { Value::Double(v.clone()) } } +impl From for Value { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } } +impl From<&f32> for Value { fn from(v: &f32) -> Self { Value::Float(Float::from(*v)) } } +impl From<&Float> for Value { fn from(v: &Float) -> Self { Value::Float(v.clone()) } } +impl From for Value { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } } +impl From<&f64> for Value { fn from(v: &f64) -> Self { Value::Double(Double::from(*v)) } } +impl From<&Double> for Value { fn from(v: &Double) -> Self { Value::Double(v.clone()) } } -impl, D: Embeddable> From for Value { fn from(v: u8) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: i8) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: u16) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: i16) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: u32) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: i32) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: u64) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: i64) -> Self { Value::from(i128::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: usize) -> Self { Value::from(v as u128) } } -impl, D: Embeddable> From for Value { fn from(v: isize) -> Self { Value::from(v as i128) } } -impl, D: Embeddable> From for Value { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } } -impl, D: Embeddable> From<&BigInt> for Value { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } } -impl, D: Embeddable> From for Value { fn from(v: BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Owned(v))) } } -impl, D: Embeddable> From<&SignedInteger> for Value { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } } +impl From for Value { fn from(v: u8) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i8) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u16) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i16) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u32) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i32) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: u64) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: i64) -> Self { Value::from(i128::from(v)) } } +impl From for Value { fn from(v: usize) -> Self { Value::from(v as u128) } } +impl From for Value { fn from(v: isize) -> Self { Value::from(v as i128) } } +impl From for Value { fn from(v: u128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } } +impl From for Value { fn from(v: i128) -> Self { Value::SignedInteger(SignedInteger::from(v)) } } +impl From<&BigInt> for Value { fn from(v: &BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Borrowed(v))) } } +impl From for Value { fn from(v: BigInt) -> Self { Value::SignedInteger(SignedInteger::from(Cow::Owned(v))) } } +impl From<&SignedInteger> for Value { fn from(v: &SignedInteger) -> Self { Value::SignedInteger(v.clone()) } } -impl, D: Embeddable> From<&str> for Value { fn from(v: &str) -> Self { Value::String(String::from(v)) } } -impl, D: Embeddable> From for Value { fn from(v: String) -> Self { Value::String(v) } } -impl, D: Embeddable> From<&String> for Value { fn from(v: &String) -> Self { Value::String(v.to_owned()) } } +impl From<&str> for Value { fn from(v: &str) -> Self { Value::String(String::from(v)) } } +impl From for Value { fn from(v: String) -> Self { Value::String(v) } } +impl From<&String> for Value { fn from(v: &String) -> Self { Value::String(v.to_owned()) } } -impl, D: Embeddable> From<&[u8]> for Value { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } } -// impl, D: Embeddable> From> for Value { fn from(v: Vec) -> Self { Value::ByteString(v) } } +impl From<&[u8]> for Value { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } } +// impl From> for Value { fn from(v: Vec) -> Self { Value::ByteString(v) } } -impl, D: Embeddable> From> for Value { fn from(v: Vec) -> Self { Value::Sequence(v) } } -impl, D: Embeddable> From> for Value { fn from(v: Set) -> Self { Value::Set(v) } } -impl, D: Embeddable> From> for Value { fn from(v: Map) -> Self { Value::Dictionary(v) } } +impl From> for Value { fn from(v: Vec) -> Self { Value::Sequence(v) } } +impl From> for Value { fn from(v: Set) -> Self { Value::Set(v) } } +impl From> for Value { fn from(v: Map) -> Self { Value::Dictionary(v) } } -impl, D: Embeddable> Debug for Value { +impl Debug for Value { // Not *quite* a formatter for the Preserves text syntax, since it // doesn't escape strings/symbols properly. fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -339,7 +340,7 @@ impl, D: Embeddable> Debug for Value { //--------------------------------------------------------------------------- -impl, D: Embeddable> Value { +impl Value { pub fn wrap(self) -> N { N::wrap(Annotations::empty(), self) } @@ -690,7 +691,7 @@ impl, D: Embeddable> Value { self.as_bytestring().ok_or_else(|| self.expected(ExpectedKind::ByteString)) } - pub fn symbol(s: &str) -> Value { + pub fn symbol(s: &str) -> Value { Value::Symbol(s.to_string()) } @@ -767,11 +768,11 @@ impl, D: Embeddable> Value { Self::record(N::symbol(label), expected_arity) } - pub fn simple_record0(label: &str) -> Value { + pub fn simple_record0(label: &str) -> Value { Self::simple_record(label, 0).finish() } - pub fn simple_record1(label: &str, field: N) -> Value { + pub fn simple_record1(label: &str, field: N) -> Value { let mut r = Self::simple_record(label, 1); r.fields_vec_mut().push(field); r.finish() @@ -904,7 +905,7 @@ impl, D: Embeddable> Value { self.as_embedded().is_some() } - pub fn as_embedded(&self) -> Option<&D> { + pub fn as_embedded(&self) -> Option<&N::D> { if let Value::Embedded(d) = self { Some(d) } else { @@ -912,13 +913,13 @@ impl, D: Embeddable> Value { } } - pub fn to_embedded(&self) -> Result<&D, Error> { + pub fn to_embedded(&self) -> Result<&N::D, Error> { self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded)) } - pub fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result, Err> + pub fn copy_via(&self, f: &mut F) -> Result, Err> where - F: FnMut(&D) -> Result, Err> + F: FnMut(&N::D) -> Result, Err> { Ok(match self { Value::Boolean(b) => Value::Boolean(*b), @@ -944,7 +945,7 @@ impl, D: Embeddable> Value { pub fn foreach_embedded(&self, f: &mut F) -> Result<(), Err> where - F: FnMut(&D) -> Result<(), Err> + F: FnMut(&N::D) -> Result<(), Err> { match self { Value::Boolean(_) | @@ -966,7 +967,7 @@ impl, D: Embeddable> Value { } } -impl, D: Embeddable> Index for Value { +impl Index for Value { type Output = N; fn index(&self, i: usize) -> &Self::Output { @@ -974,13 +975,13 @@ impl, D: Embeddable> Index for Value { } } -impl, D: Embeddable> IndexMut for Value { +impl IndexMut for Value { fn index_mut(&mut self, i: usize) -> &mut Self::Output { &mut self.as_sequence_mut().unwrap()[i] } } -impl, D: Embeddable> Index<&N> for Value { +impl Index<&N> for Value { type Output = N; fn index(&self, i: &N) -> &Self::Output { @@ -1006,16 +1007,15 @@ impl<'de> serde::Deserialize<'de> for UnwrappedIOValue { //--------------------------------------------------------------------------- #[derive(Clone)] -pub struct Annotations, D: Embeddable>(Option>, PhantomData); +pub struct Annotations(Option>); -impl, D: Embeddable> Annotations { +impl Annotations { pub fn empty() -> Self { - Annotations(None, - PhantomData) + Annotations(None) } pub fn new(anns: Option>) -> Self { - Annotations(anns, PhantomData) + Annotations(anns) } pub fn maybe_slice(&self) -> Option<&[N]> { @@ -1043,16 +1043,15 @@ impl, D: Embeddable> Annotations { self } - pub fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result, Err> + pub fn copy_via(&self, f: &mut F) -> Result, Err> where - F: FnMut(&D) -> Result, Err> + F: FnMut(&N::D) -> Result, Err> { Ok(match &self.0 { None => - Annotations(None, PhantomData), + Annotations(None), Some(b) => - Annotations(Some(b.iter().map(|a| a.copy_via(f)).collect::, _>>()?), - PhantomData), + Annotations(Some(b.iter().map(|a| a.copy_via(f)).collect::, _>>()?)), }) } } @@ -1060,35 +1059,35 @@ impl, D: Embeddable> Annotations { /// A possibly-annotated Value, with annotations (themselves /// possibly-annotated) in order of appearance. #[derive(Clone)] -pub struct AnnotatedValue, D: Embeddable>(pub Annotations, pub Value); +pub struct AnnotatedValue(pub Annotations, pub Value); -impl, D: Embeddable> AnnotatedValue { - fn new(anns: Annotations, value: Value) -> Self { +impl AnnotatedValue { + fn new(anns: Annotations, value: Value) -> Self { AnnotatedValue(anns, value) } } -impl, D: Embeddable> PartialEq for AnnotatedValue { +impl PartialEq for AnnotatedValue { fn eq(&self, other: &Self) -> bool { self.1.eq(&other.1) } } -impl, D: Embeddable> Eq for AnnotatedValue {} +impl Eq for AnnotatedValue {} -impl, D: Embeddable> Hash for AnnotatedValue { +impl Hash for AnnotatedValue { fn hash(&self, state: &mut H) { self.1.hash(state); } } -impl, D: Embeddable> PartialOrd for AnnotatedValue { +impl PartialOrd for AnnotatedValue { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } -impl, D: Embeddable> Ord for AnnotatedValue { +impl Ord for AnnotatedValue { fn cmp(&self, other: &Self) -> Ordering { self.1.cmp(&other.1) } @@ -1097,37 +1096,39 @@ impl, D: Embeddable> Ord for AnnotatedValue { //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct PlainValue(AnnotatedValue, D>); +pub struct PlainValue(AnnotatedValue>); impl PlainValue { - pub fn annotations_mut(&mut self) -> &mut Annotations { + pub fn annotations_mut(&mut self) -> &mut Annotations { &mut (self.0).0 } - pub fn value_mut(&mut self) -> &mut Value { + pub fn value_mut(&mut self) -> &mut Value { &mut (self.0).1 } } -impl NestedValue for PlainValue { - fn wrap(anns: Annotations, v: Value) -> Self { +impl NestedValue for PlainValue { + type D = D; + + fn wrap(anns: Annotations, v: Value) -> Self { PlainValue(AnnotatedValue::new(anns, v)) } - fn annotations(&self) -> &Annotations { + fn annotations(&self) -> &Annotations { &(self.0).0 } - fn value(&self) -> &Value { + fn value(&self) -> &Value { &(self.0).1 } - fn pieces(self) -> (Annotations, Value) { + fn pieces(self) -> (Annotations, Value) { let AnnotatedValue(anns, v) = self.0; (anns, v) } - fn value_owned(self) -> Value { + fn value_owned(self) -> Value { (self.0).1 } } @@ -1143,29 +1144,31 @@ impl Debug for PlainValue { use std::rc::Rc; #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct RcValue(Rc, D>>); +pub struct RcValue(Rc>>); -impl NestedValue for RcValue { - fn wrap(anns: Annotations, v: Value) -> Self { +impl NestedValue for RcValue { + type D = D; + + fn wrap(anns: Annotations, v: Value) -> Self { RcValue(Rc::new(AnnotatedValue::new(anns, v))) } - fn annotations(&self) -> &Annotations { + fn annotations(&self) -> &Annotations { &(self.0).0 } - fn value(&self) -> &Value { + fn value(&self) -> &Value { &(self.0).1 } - fn pieces(self) -> (Annotations, Value) { + fn pieces(self) -> (Annotations, Value) { match Rc::try_unwrap(self.0) { Ok(AnnotatedValue(anns, v)) => (anns, v), Err(r) => (r.0.clone(), r.1.clone()), } } - fn value_owned(self) -> Value { + fn value_owned(self) -> Value { Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1 } } @@ -1179,29 +1182,31 @@ impl Debug for RcValue { //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct ArcValue(Arc, D>>); +pub struct ArcValue(Arc>>); -impl NestedValue for ArcValue { - fn wrap(anns: Annotations, v: Value) -> Self { +impl NestedValue for ArcValue { + type D = D; + + fn wrap(anns: Annotations, v: Value) -> Self { ArcValue(Arc::new(AnnotatedValue::new(anns, v))) } - fn annotations(&self) -> &Annotations { + fn annotations(&self) -> &Annotations { &(self.0).0 } - fn value(&self) -> &Value { + fn value(&self) -> &Value { &(self.0).1 } - fn pieces(self) -> (Annotations, Value) { + fn pieces(self) -> (Annotations, Value) { match Arc::try_unwrap(self.0) { Ok(AnnotatedValue(anns, v)) => (anns, v), Err(r) => (r.0.clone(), r.1.clone()), } } - fn value_owned(self) -> Value { + fn value_owned(self) -> Value { Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1 } } @@ -1215,32 +1220,34 @@ impl Debug for ArcValue { //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct IOValue(Arc>); -pub type UnwrappedIOValue = Value; +pub struct IOValue(Arc>); +pub type UnwrappedIOValue = Value; impl Domain for IOValue {} -impl NestedValue for IOValue { - fn wrap(anns: Annotations, v: Value) -> Self { +impl NestedValue for IOValue { + type D = Self; + + fn wrap(anns: Annotations, v: Value) -> Self { IOValue(Arc::new(AnnotatedValue::new(anns, v))) } - fn annotations(&self) -> &Annotations { + fn annotations(&self) -> &Annotations { &(self.0).0 } - fn value(&self) -> &Value { + fn value(&self) -> &Value { &(self.0).1 } - fn pieces(self) -> (Annotations, Value) { + fn pieces(self) -> (Annotations, Value) { match Arc::try_unwrap(self.0) { Ok(AnnotatedValue(anns, v)) => (anns, v), Err(r) => (r.0.clone(), r.1.clone()), } } - fn value_owned(self) -> Value { + fn value_owned(self) -> Value { match Arc::try_unwrap(self.0) { Ok(AnnotatedValue(_anns, v)) => v, Err(r) => r.1.clone(), @@ -1269,7 +1276,7 @@ impl<'de> serde::Deserialize<'de> for IOValue { //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub struct DummyValue(AnnotatedValue, D>); +pub struct DummyValue(AnnotatedValue>); impl Debug for DummyValue { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { @@ -1277,31 +1284,32 @@ impl Debug for DummyValue { } } - impl DummyValue { pub fn new() -> Self { DummyValue(AnnotatedValue::new(Annotations::empty(), Value::Boolean(false))) } } -impl NestedValue for DummyValue { - fn wrap(_anns: Annotations, _v: Value) -> Self { +impl NestedValue for DummyValue { + type D = D; + + fn wrap(_anns: Annotations, _v: Value) -> Self { DummyValue::new() } - fn annotations(&self) -> &Annotations { + fn annotations(&self) -> &Annotations { &self.0.0 } - fn value(&self) -> &Value { + fn value(&self) -> &Value { &self.0.1 } - fn pieces(self) -> (Annotations, Value) { + fn pieces(self) -> (Annotations, Value) { (self.0.0, self.0.1) } - fn value_owned(self) -> Value { + fn value_owned(self) -> Value { self.0.1 } } diff --git a/implementations/rust/preserves/src/value/text/mod.rs b/implementations/rust/preserves/src/value/text/mod.rs index 80854ff..5ecc258 100644 --- a/implementations/rust/preserves/src/value/text/mod.rs +++ b/implementations/rust/preserves/src/value/text/mod.rs @@ -8,9 +8,9 @@ use crate::value::reader::BytesBinarySource; use std::io; -use super::{DomainParse, Embeddable, IOValue, IOValueDomainCodec, NestedValue, Reader, ViaCodec}; +use super::{DomainParse, IOValue, IOValueDomainCodec, NestedValue, Reader, ViaCodec}; -pub fn from_str, Dec: DomainParse>( +pub fn from_str>( s: &str, decode_embedded: Dec, ) -> io::Result { @@ -21,7 +21,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result { from_str(s, ViaCodec::new(IOValueDomainCodec)) } -pub fn annotated_from_str, Dec: DomainParse>( +pub fn annotated_from_str>( s: &str, decode_embedded: Dec, ) -> io::Result { diff --git a/implementations/rust/preserves/src/value/text/reader.rs b/implementations/rust/preserves/src/value/text/reader.rs index bdf455a..fbb1a51 100644 --- a/implementations/rust/preserves/src/value/text/reader.rs +++ b/implementations/rust/preserves/src/value/text/reader.rs @@ -50,7 +50,9 @@ fn append_codepoint(bs: &mut Vec, n: u32) -> io::Result<()> { Ok(()) } -impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextReader<'de, 'src, D, Dec, S> { +impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> + TextReader<'de, 'src, D, Dec, S> +{ pub fn new(source: &'src mut S, dec: Dec) -> Self { TextReader { source, @@ -87,14 +89,14 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } // TODO: This is a duplicate of fn expected in PackedReader. - fn expected>(&mut self, k: ExpectedKind) -> Error { - match Reader::::demand_next(self, true) { + fn expected>(&mut self, k: ExpectedKind) -> Error { + match Reader::::demand_next(self, true) { Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))), Err(e) => e.into() } } - fn gather_annotations>(&mut self) -> ReaderResult> { + fn gather_annotations>(&mut self) -> ReaderResult> { let mut vs = Vec::new(); loop { self.skip_whitespace(); @@ -111,7 +113,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe self.skip_whitespace(); match self.peek()? { b';' => { self.skip()?; self.comment_line()?; }, - b'@' => { self.skip()?; Reader::>::skip_value(self)?; }, + b'@' => { self.skip()?; Reader::>::skip_value(self)?; }, _ => return Ok(()), } } @@ -135,7 +137,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } - fn read_intpart>(&mut self, mut bs: Vec, c: u8) -> io::Result { + fn read_intpart(&mut self, mut bs: Vec, c: u8) -> io::Result { match c { b'0' => { bs.push(c); @@ -148,7 +150,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } - fn read_fracexp>(&mut self, mut bs: Vec) -> io::Result { + fn read_fracexp(&mut self, mut bs: Vec) -> io::Result { let mut is_float = false; match self.peek() { Ok(b'.') => { @@ -168,7 +170,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } - fn read_sign_and_exp>(&mut self, mut bs: Vec) -> io::Result { + fn read_sign_and_exp(&mut self, mut bs: Vec) -> io::Result { match self.peek()? { b'+' | b'-' => bs.push(self.next_byte()?), _ => (), @@ -178,7 +180,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe self.finish_number(bs, true) } - fn finish_number>(&mut self, bs: Vec, is_float: bool) -> io::Result { + fn finish_number(&mut self, bs: Vec, is_float: bool) -> io::Result { let s = decode_utf8(bs)?; if is_float { match self.peek() { @@ -288,7 +290,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe })?) } - fn read_literal_binary>(&mut self) -> io::Result { + fn read_literal_binary(&mut self) -> io::Result { Ok(N::new(&self.read_stringlike( Vec::new(), |bs, b| Ok(bs.push(b)), @@ -297,7 +299,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe |bs, r| Ok(bs.push(r.hexnum(2)? as u8)))?[..])) } - fn read_hex_binary>(&mut self) -> io::Result { + fn read_hex_binary(&mut self) -> io::Result { let mut s = String::new(); loop { self.skip_whitespace(); @@ -315,7 +317,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } - fn read_base64_binary>(&mut self) -> io::Result { + fn read_base64_binary(&mut self) -> io::Result { let mut bs = Vec::new(); loop { self.skip_whitespace(); @@ -332,7 +334,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } - fn upto>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result> { + fn upto>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result> { let mut vs = Vec::new(); loop { self.skip_whitespace(); @@ -340,11 +342,11 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe self.skip()?; return Ok(vs); } - vs.push(Reader::::demand_next(self, read_annotations)?); + vs.push(Reader::::demand_next(self, read_annotations)?); } } - fn read_dictionary>(&mut self, read_annotations: bool) -> io::Result { + fn read_dictionary>(&mut self, read_annotations: bool) -> io::Result { let mut d = Map::new(); loop { self.skip_whitespace(); @@ -352,17 +354,17 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe self.skip()?; return Ok(N::new(d)); } - let k = Reader::::demand_next(self, read_annotations)?; + let k = Reader::::demand_next(self, read_annotations)?; self.skip_whitespace(); if self.next_byte()? != b':' { return Err(io_syntax_error("Missing expected key/value separator")); } - let v = Reader::::demand_next(self, read_annotations)?; + let v = Reader::::demand_next(self, read_annotations)?; d.insert(k, v); } } - fn read_raw_symbol>(&mut self, mut bs: Vec) -> io::Result { + fn read_raw_symbol(&mut self, mut bs: Vec) -> io::Result { loop { let c = match self.peek() { Err(e) if is_eof_io_error(&e) => b' ', @@ -383,8 +385,8 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse, S: BinarySource<'de>> TextRe } } -impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: BinarySource<'de>> - Reader<'de, D, N> for TextReader<'de, 'src, D, Dec, S> +impl<'de, 'src, N: NestedValue, Dec: DomainParse, S: BinarySource<'de>> + Reader<'de, N> for TextReader<'de, 'src, N::D, Dec, S> { fn next(&mut self, read_annotations: bool) -> io::Result> { self.skip_whitespace(); @@ -415,7 +417,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary if read_annotations { let mut annotations = self.gather_annotations()?; let (existing_annotations, v) = - Reader::::demand_next(self, read_annotations)?.pieces(); + Reader::::demand_next(self, read_annotations)?.pieces(); annotations.extend_from_slice(existing_annotations.slice()); N::wrap(Annotations::new(Some(annotations)), v) } else { @@ -491,13 +493,13 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary if self.peek()? != b'<' { return Err(self.expected::(ExpectedKind::Record(arity))); } self.skip()?; let mut b = B::Type::default(); - Reader::::ensure_more_expected(self, &mut b, &B::Item::RecordLabel)?; + Reader::::ensure_more_expected(self, &mut b, &B::Item::RecordLabel)?; Ok(b) } fn open_sequence_or_set(&mut self) -> ReaderResult { self.skip_annotations()?; - let mark = Reader::::mark(self)?; + let mark = Reader::::mark(self)?; match self.next_byte()? { b'#' => match self.next_byte()? { b'{' => return Ok(B::Item::SetValue), @@ -506,7 +508,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary b'[' => return Ok(B::Item::SequenceValue), _ => (), } - Reader::::restore(self, &mark)?; + Reader::::restore(self, &mark)?; Err(self.expected::(ExpectedKind::SequenceOrSet)) } @@ -519,7 +521,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary fn open_set(&mut self) -> ReaderResult<()> { self.skip_annotations()?; - let mark = Reader::::mark(self)?; + let mark = Reader::::mark(self)?; match self.next_byte()? { b'#' => match self.next_byte()? { b'{' => return Ok(()), @@ -527,7 +529,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary }, _ => (), } - Reader::::restore(self, &mark)?; + Reader::::restore(self, &mark)?; Err(self.expected::(ExpectedKind::Set)) } @@ -564,7 +566,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary } _ => { b.shift(Some(i.clone())); - Reader::::boundary(self, b)?; + Reader::::boundary(self, b)?; Ok(false) } } @@ -572,7 +574,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary fn open_embedded(&mut self) -> ReaderResult<()> { self.skip_annotations()?; - let mark = Reader::::mark(self)?; + let mark = Reader::::mark(self)?; match self.next_byte()? { b'#' => match self.next_byte()? { b'!' => return Ok(()), @@ -580,7 +582,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary }, _ => (), } - Reader::::restore(self, &mark)?; + Reader::::restore(self, &mark)?; Err(self.expected::(ExpectedKind::Embedded)) } @@ -598,9 +600,9 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary self.source.restore(mark) } - fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { + fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result> { self.skip_annotations()?; - let mark = Reader::::mark(self)?; + let mark = Reader::::mark(self)?; Ok(match self.next_byte()? { b'<' => Token::Compound(CompoundClass::Record), b'[' => Token::Compound(CompoundClass::Sequence), @@ -615,18 +617,18 @@ impl<'de, 'src, D: Embeddable, N: NestedValue, Dec: DomainParse, S: Binary } b'{' => Token::Compound(CompoundClass::Set), _ => { - Reader::::restore(self, &mark)?; + Reader::::restore(self, &mark)?; Token::Atom(self.demand_next(false)?) } }, _ => { - Reader::::restore(self, &mark)?; + Reader::::restore(self, &mark)?; Token::Atom(self.demand_next(false)?) } }) } - fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { + fn next_annotations_and_token(&mut self) -> io::Result<(Vec, Token)> { let annotations = self.gather_annotations()?; Ok((annotations, self.next_token(true)?)) } diff --git a/implementations/rust/preserves/src/value/text/writer.rs b/implementations/rust/preserves/src/value/text/writer.rs index 8ac796d..06cc779 100644 --- a/implementations/rust/preserves/src/value/text/writer.rs +++ b/implementations/rust/preserves/src/value/text/writer.rs @@ -1,5 +1,4 @@ use crate::value::DomainEncode; -use crate::value::Embeddable; use crate::value::IOValue; use crate::value::IOValueDomainCodec; use crate::value::NestedValue; @@ -35,7 +34,7 @@ impl std::default::Default for CommaStyle { } impl TextWriter<&mut Vec> { - pub fn encode, Enc: DomainEncode>( + pub fn encode>( enc: &mut Enc, v: &N, ) -> io::Result { diff --git a/implementations/rust/preserves/src/value/writer.rs b/implementations/rust/preserves/src/value/writer.rs index 6746721..9fc37f1 100644 --- a/implementations/rust/preserves/src/value/writer.rs +++ b/implementations/rust/preserves/src/value/writer.rs @@ -3,7 +3,7 @@ use std::io; use super::DomainEncode; use super::boundary as B; use super::signed_integer::SignedIntegerRepr; -use super::repr::{Embeddable, Value, NestedValue, Float, Double}; +use super::repr::{Value, NestedValue, Float, Double}; pub trait CompoundWriter: Writer { fn boundary(&mut self, b: &B::Type) -> io::Result<()>; @@ -58,7 +58,7 @@ pub trait Writer: Sized { //--------------------------------------------------------------------------- - fn write, Enc: DomainEncode>( + fn write>( &mut self, enc: &mut Enc, v: &N, @@ -86,10 +86,10 @@ pub trait Writer: Sized { Ok(()) } - fn write_value, Enc: DomainEncode>( + fn write_value>( &mut self, enc: &mut Enc, - v: &Value, + v: &Value, ) -> io::Result<()> { match v { Value::Boolean(b) => self.write_bool(*b),