From 83d15a838e5771e7c8138bee8ef909fa25dbb77e Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Sat, 3 Jul 2021 23:10:43 +0200 Subject: [PATCH] Remove mostly-useless Domain methods --- implementations/rust/preserves/src/error.rs | 3 +- implementations/rust/preserves/src/lib.rs | 25 ++-- .../rust/preserves/src/value/de.rs | 2 +- .../rust/preserves/src/value/packed/reader.rs | 2 +- .../rust/preserves/src/value/repr.rs | 118 +++--------------- 5 files changed, 28 insertions(+), 122 deletions(-) diff --git a/implementations/rust/preserves/src/error.rs b/implementations/rust/preserves/src/error.rs index 0a1a3dc..d86513f 100644 --- a/implementations/rust/preserves/src/error.rs +++ b/implementations/rust/preserves/src/error.rs @@ -1,6 +1,5 @@ use num::bigint::BigInt; use std::convert::From; -use crate::value::IOValue; #[derive(Debug)] pub enum Error { @@ -19,7 +18,7 @@ pub enum Error { pub enum Received { ReceivedSomethingElse, ReceivedRecordWithLabel(String), - ReceivedOtherValue(IOValue), + ReceivedOtherValue(String), } #[derive(Debug, PartialEq)] diff --git a/implementations/rust/preserves/src/lib.rs b/implementations/rust/preserves/src/lib.rs index 6c1e3b3..3533ae5 100644 --- a/implementations/rust/preserves/src/lib.rs +++ b/implementations/rust/preserves/src/lib.rs @@ -10,10 +10,7 @@ pub mod value; #[cfg(test)] mod dom { - use super::value::{ - Value, IOValue, IOResult, NestedValue, PlainValue, Domain, - PackedWriter, - }; + use super::value::*; #[derive(Debug, Hash, Clone, Ord, PartialEq, Eq, PartialOrd)] pub enum Dom { @@ -21,17 +18,13 @@ mod dom { Two, } - impl Domain for Dom { - fn from_preserves(v: IOValue) -> IOResult { - panic!("Cannot decode IOValue to Dom: {:?}", v); - } + impl Domain for Dom {} - fn as_preserves(&self) -> IOValue { - match self { - Dom::One => Value::ByteString(vec![255, 255, 255, 255]).wrap(), - Dom::Two => Value::symbol(&format!("Dom::{:?}", self)).wrap(), - } - } + fn dom_as_preserves(v: &Dom) -> IOResult { + Ok(match v { + Dom::One => Value::ByteString(vec![255, 255, 255, 255]), + Dom::Two => Value::symbol(&format!("Dom::{:?}", v)), + }) } #[test] fn test_one() { @@ -39,7 +32,7 @@ mod dom { Value::Embedded(Dom::One).wrap(), Value::from(2).wrap()]) .wrap(); - assert_eq!(PackedWriter::encode(&v.to_io_value()).unwrap(), + assert_eq!(PackedWriter::encode(&v.copy_via(&mut dom_as_preserves).unwrap()).unwrap(), [0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]); } @@ -48,7 +41,7 @@ mod dom { Value::Embedded(Dom::Two).wrap(), Value::from(2).wrap()]) .wrap(); - assert_eq!(PackedWriter::encode(&v.to_io_value()).unwrap(), + assert_eq!(PackedWriter::encode(&v.copy_via(&mut dom_as_preserves).unwrap()).unwrap(), [0xb5, 0x91, 0xb3, 0x08, 68, 111, 109, 58, 58, 84, 119, 111, 0x92, 0x84]); } } diff --git a/implementations/rust/preserves/src/value/de.rs b/implementations/rust/preserves/src/value/de.rs index 3857701..1ce8370 100644 --- a/implementations/rust/preserves/src/value/de.rs +++ b/implementations/rust/preserves/src/value/de.rs @@ -27,7 +27,7 @@ impl<'de> Deserializer<'de> { where F: FnOnce(&'de UnwrappedIOValue) -> Option { f(self.input.value()).ok_or_else( - || Error::Expected(k, Received::ReceivedOtherValue(self.input.clone()))) + || Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", self.input)))) } } diff --git a/implementations/rust/preserves/src/value/packed/reader.rs b/implementations/rust/preserves/src/value/packed/reader.rs index af7f417..64a11b6 100644 --- a/implementations/rust/preserves/src/value/packed/reader.rs +++ b/implementations/rust/preserves/src/value/packed/reader.rs @@ -80,7 +80,7 @@ impl<'de, S: BinarySource<'de>> PackedReader<'de, S> { fn expected(&mut self, k: ExpectedKind) -> error::Error { match self.demand_next(true) { - Ok(v) => error::Error::Expected(k, Received::ReceivedOtherValue(v)), + Ok(v) => error::Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))), Err(e) => e.into() } } diff --git a/implementations/rust/preserves/src/value/repr.rs b/implementations/rust/preserves/src/value/repr.rs index ed293de..adbd97b 100644 --- a/implementations/rust/preserves/src/value/repr.rs +++ b/implementations/rust/preserves/src/value/repr.rs @@ -17,27 +17,14 @@ use std::vec::Vec; pub use std::collections::BTreeSet as Set; pub use std::collections::BTreeMap as Map; -use super::IOResult; use super::signed_integer::SignedInteger; use crate::error::{Error, ExpectedKind, Received}; -pub trait Domain: Sized + Debug + Eq + Hash + Ord { - fn from_preserves(v: IOValue) -> IOResult; - fn as_preserves(&self) -> IOValue; -} - +pub trait Domain: Sized + Debug + Eq + Hash + Ord {} pub trait Embeddable: Domain + Clone {} impl Embeddable for T where T: Domain + Clone {} -impl Domain for Arc { - fn from_preserves(v: IOValue) -> IOResult { - Ok(Arc::new(D::from_preserves(v)?)) - } - - fn as_preserves(&self) -> IOValue { - D::as_preserves(self) - } -} +impl Domain for Arc {} pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { fn new(v: V) -> Self where Value: From { @@ -58,20 +45,12 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { self.value().fmt(f) } - fn copy_via, E: Embeddable, F>(&self, f: &F) -> IOResult + fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result where - F: Fn(&D) -> IOResult> + F: FnMut(&D) -> Result, Err> { Ok(M::wrap(self.annotations().copy_via(f)?, self.value().copy_via(f)?)) } - - fn to_io_value(&self) -> IOValue { - self.copy_via(&|d| Ok(d.as_preserves().value().clone())).unwrap() - } - - fn from_io_value(v: &IOValue) -> IOResult { - v.copy_via(&|d| Ok(Value::Embedded(D::from_preserves(d.clone())?))) - } } /// The `Value`s from the specification. @@ -304,7 +283,7 @@ impl, D: Embeddable> Value { } fn expected(&self, k: ExpectedKind) -> Error { - Error::Expected(k, Received::ReceivedOtherValue(self.clone().wrap().to_io_value())) + Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", self.clone().wrap()))) } pub fn is_boolean(&self) -> bool { @@ -792,9 +771,9 @@ impl, D: Embeddable> Value { self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded)) } - pub fn copy_via, E: Embeddable, F>(&self, f: &F) -> IOResult> + pub fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result, Err> where - F: Fn(&D) -> IOResult> + F: FnMut(&D) -> Result, Err> { Ok(match self { Value::Boolean(b) => Value::Boolean(*b), @@ -808,12 +787,12 @@ impl, D: Embeddable> Value { Value::Record(Record(r.fields_vec().iter().map(|a| a.copy_via(f)) .collect::, _>>()?)), Value::Sequence(v) => Value::Sequence(v.iter().map(|a| a.copy_via(f)) - .collect::>>()?), + .collect::, _>>()?), Value::Set(v) => Value::Set(v.iter().map(|a| a.copy_via(f)) - .collect::>>()?), + .collect::, _>>()?), Value::Dictionary(v) => Value::Dictionary(v.iter().map(|(a,b)| Ok((a.copy_via(f)?, b.copy_via(f)?))) - .collect::>>()?), + .collect::, _>>()?), Value::Embedded(d) => f(d)?, }) } @@ -856,19 +835,6 @@ impl<'de> serde::Deserialize<'de> for UnwrappedIOValue { } } -pub fn serialize_nested_value(v: &N, serializer: S) -> - Result where S: serde::Serializer, N: NestedValue + serde::Serialize -{ - super::magic::output_value(serializer, v.to_io_value()) -} - -pub fn deserialize_nested_value<'de, D, N, Dom: Embeddable>(deserializer: D) -> - Result where D: serde::Deserializer<'de>, N: NestedValue + serde::Deserialize<'de> -{ - N::from_io_value(&super::magic::input_value(deserializer)?) - .map_err(|e| serde::de::Error::custom(format!("{:?}", e))) -} - //--------------------------------------------------------------------------- #[derive(Clone)] @@ -905,9 +871,9 @@ impl, D: Embeddable> Annotations { self } - pub fn copy_via, E: Embeddable, F>(&self, f: &F) -> IOResult> + pub fn copy_via, E: Embeddable, F, Err>(&self, f: &mut F) -> Result, Err> where - F: Fn(&D) -> IOResult> + F: FnMut(&D) -> Result, Err> { Ok(match &self.0 { None => @@ -1000,18 +966,6 @@ impl Debug for PlainValue { } } -impl serde::Serialize for PlainValue { - fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - serialize_nested_value(self, serializer) - } -} - -impl<'de, Dom: Embeddable> serde::Deserialize<'de> for PlainValue { - fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - deserialize_nested_value(deserializer) - } -} - //--------------------------------------------------------------------------- use std::rc::Rc; @@ -1050,18 +1004,6 @@ impl Debug for RcValue { } } -impl serde::Serialize for RcValue { - fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - serialize_nested_value(self, serializer) - } -} - -impl<'de, Dom: Embeddable> serde::Deserialize<'de> for RcValue { - fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - deserialize_nested_value(deserializer) - } -} - //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] @@ -1098,40 +1040,20 @@ impl Debug for ArcValue { } } -impl serde::Serialize for ArcValue { - fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - serialize_nested_value(self, serializer) - } -} - -impl<'de, Dom: Embeddable> serde::Deserialize<'de> for ArcValue { - fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - deserialize_nested_value(deserializer) - } -} - //--------------------------------------------------------------------------- #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct IOValue(Arc>); pub type UnwrappedIOValue = Value; -impl Domain for IOValue { - fn from_preserves(v: IOValue) -> IOResult { - Ok(v) - } - - fn as_preserves(&self) -> IOValue { - self.clone() - } -} - lazy_static! { pub static ref FALSE: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Boolean(false)))); pub static ref TRUE: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Boolean(true)))); pub static ref EMPTY_SEQ: IOValue = IOValue(Arc::new(AnnotatedValue(Annotations::empty(), Value::Sequence(Vec::new())))); } +impl Domain for IOValue {} + impl NestedValue for IOValue { fn wrap(anns: Annotations, v: Value) -> Self { IOValue(Arc::new(AnnotatedValue::new(anns, v))) @@ -1158,14 +1080,6 @@ impl NestedValue for IOValue { Err(r) => r.1.clone(), } } - - fn to_io_value(&self) -> IOValue { - self.clone() - } - - fn from_io_value(v: &IOValue) -> IOResult { - Ok(v.clone()) - } } impl Debug for IOValue { @@ -1176,12 +1090,12 @@ impl Debug for IOValue { impl serde::Serialize for IOValue { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer { - serialize_nested_value(self, serializer) + super::magic::output_value(serializer, self.clone()) } } impl<'de> serde::Deserialize<'de> for IOValue { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { - deserialize_nested_value(deserializer) + super::magic::input_value(deserializer) } }