syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Another failure

This commit is contained in:
Tony Garnock-Jones 2022-11-17 09:43:04 +01:00
parent ce9d4f2f0c
commit 5a5ff987b7
9 changed files with 345 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
implementations/rust/preserves/src/lib.rs
View File

@ -22,13 +22,11 @@ pub use packed::iovalue_from_bytes;
pub use reader::IOValues;
pub use reader::Reader;
pub use repr::Annotations;
pub use repr::ArcValue;
pub use repr::Atom;
pub use repr::Bytes;
pub use repr::Embedded;
pub use repr::IOValue;
pub use repr::Map;
pub use repr::PlainValue;
pub use repr::NoValue;
pub use repr::Record;
pub use repr::Set;
@ -36,9 +34,6 @@ pub use repr::Symbol;
pub use repr::Value;
pub use repr::ValueImpl;
pub use repr::copy_via;
pub use repr::iovalue;
pub use repr::owned;
pub use repr::shell;
pub use repr::value;
pub use signed_integer::SignedInteger;
pub use source::BinarySource;
@ -65,24 +60,24 @@ mod demo {
// }
#[test] fn a() {
let l: PlainValue<NoValue> = "label".parse().unwrap();
let r = Record::new(l.value_clone(), vec![owned(1), owned(2), owned(3)]);
let r2 = Record::new(l, vec![owned(1), owned(2), owned(4)]);
let l: Value<NoValue> = "label".parse().unwrap();
let r = Record::new(l.value_clone(), vec![value(1), value(2), value(3)]);
let r2 = Record::new(l, vec![value(1), value(2), value(4)]);
let mut v: Map<PlainValue<NoValue>, PlainValue<NoValue>> = Map::new();
let mut v: Map<Value<NoValue>, Value<NoValue>> = Map::new();
v.insert("\"abc\"".parse().unwrap(), "def".parse().unwrap());
v.insert("abc".parse().unwrap(), "DEF".parse().unwrap());
v.insert(owned(123), "xyz".parse().unwrap());
v.insert(owned(vec![1, 2, 3]), "{a: 1, b: 2}".parse().unwrap());
v.insert(owned(r2), "bbb".parse().unwrap());
v.insert(owned(r), "<foo bar zot>".parse().unwrap());
v.insert(value(123), "xyz".parse().unwrap());
v.insert(vec![1, 2, 3].into(), "{a: 1, b: 2}".parse().unwrap());
v.insert(value(r2), "bbb".parse().unwrap());
v.insert(value(r), "<foo bar zot>".parse().unwrap());
let w: &dyn ValueImpl<NoValue> = &v;
println!("GETw abc {:?}", w.get(&"abc"));
println!("GETw 123 {:?}", w.get(&123));
println!("GETw qqq {:?}", w.get(&"qqq"));
println!("GETv abc {:?}", v.get(&*value(&"abc")));
println!("GETv 123 {:?}", v.get(&*value(&123)));
println!("GETv qqq {:?}", v.get(&*value(&"qqq")));
println!("GETw abc {:?}", w.get(&value("abc")));
println!("GETw 123 {:?}", w.get(&value(123)));
println!("GETw qqq {:?}", w.get(&value("qqq")));
println!("GETv abc {:?}", v.get(&value("abc")));
println!("GETv 123 {:?}", v.get(&value(123)));
println!("GETv qqq {:?}", v.get(&value("qqq")));
for (kk, vv) in w.entries() {
println!("{:#?} ==> {:#?}", kk, vv);
}
@ -99,7 +94,7 @@ mod demo {
}
#[test] fn value_size() {
println!("Value size {}", std::mem::size_of::<Value<'_, NoValue>>());
println!("Value size {}", std::mem::size_of::<Value<NoValue>>());
println!("&dyn ValueImpl size {}", std::mem::size_of::<&dyn ValueImpl<NoValue>>());
println!("Box dyn ValueImpl size {}", std::mem::size_of::<Box<dyn ValueImpl<NoValue>>>());
}
@ -162,26 +157,26 @@ mod test_domain {
}
}
fn dom_as_preserves(v: &Dom) -> io::Result<PlainValue<'static, IOValue>> {
fn dom_as_preserves(v: &Dom) -> io::Result<Value<IOValue>> {
Ok(match v {
Dom::One => owned(Bytes::new(vec![255, 255, 255, 255])),
Dom::Two => owned(Symbol::new(format!("Dom::{:?}", v))),
Dom::One => value(Bytes::new(vec![255, 255, 255, 255])),
Dom::Two => value(Symbol::new(format!("Dom::{:?}", v))),
})
}
#[test] fn test_one() {
let v = owned(vec![owned(1),
owned(Embedded::new(Dom::One)),
owned(2)]);
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(),
let v = value(vec![value(1),
value(Embedded::new(Dom::One)),
value(2)]);
assert_eq!(PackedWriter::encode_iovalue(&copy_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
[0xb5, 0x91, 0xb2, 0x04, 255, 255, 255, 255, 0x92, 0x84]);
}
#[test] fn test_two() {
let v = owned(vec![owned(1),
owned(Embedded::new(Dom::Two)),
owned(2)]);
assert_eq!(PackedWriter::encode_iovalue(&iovalue(copy_via(&v, &mut dom_as_preserves).unwrap())).unwrap(),
let v = value(vec![value(1),
value(Embedded::new(Dom::Two)),
value(2)]);
assert_eq!(PackedWriter::encode_iovalue(&copy_via(&v, &mut dom_as_preserves).unwrap().into()).unwrap(),
[0xb5, 0x91, 0xb3, 0x08, 68, 111, 109, 58, 58, 84, 119, 111, 0x92, 0x84]);
}
}

6
implementations/rust/preserves/src/packed/mod.rs
View File

@ -13,13 +13,13 @@ use crate::BytesBinarySource;
use crate::Domain;
use crate::DomainDecode;
use crate::IOValue;
use crate::PlainValue;
use crate::Reader;
use crate::Value;
pub fn from_bytes<'de, D: Domain, Dec: DomainDecode<D>>(
bs: &'de [u8],
decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> {
) -> io::Result<Value<D>> {
BytesBinarySource::new(bs).packed().next(false, decode_embedded)
}
@ -30,7 +30,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result<IOValue> {
pub fn annotated_from_bytes<'de, D: Domain, Dec: DomainDecode<D>>(
bs: &'de [u8],
decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> {
) -> io::Result<Value<D>> {
super::BytesBinarySource::new(bs).packed().next(true, decode_embedded)
}

6
implementations/rust/preserves/src/packed/reader.rs
View File

@ -300,11 +300,11 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
self.readbytes_into(&mut bs)?;
Ok(Atom::Double(f64::from_bits(u64::from_be_bytes(bs))))
}
Tag::SmallInteger(v) => Ok(Atom::SignedInteger(v.into())),
Tag::MediumInteger(count) => Ok(Atom::SignedInteger(self.read_signed_integer(count.into())?)),
Tag::SmallInteger(v) => Ok(Atom::SignedInteger(Cow::Owned(v.into()))),
Tag::MediumInteger(count) => Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count.into())?))),
Tag::SignedInteger => {
let count = self.varint()?;
Ok(Atom::SignedInteger(self.read_signed_integer(count)?))
Ok(Atom::SignedInteger(Cow::Owned(self.read_signed_integer(count)?)))
}
Tag::String => {
let count = self.varint()?;

69
implementations/rust/preserves/src/packed/view.rs
View File

@ -14,16 +14,12 @@ use crate::DomainDecode;
use crate::IOValue;
use crate::NoEmbeddedDomainCodec;
use crate::PackedWriter;
use crate::PlainValue;
use crate::SignedInteger;
use crate::Value;
use crate::ValueClass;
use crate::ValueImpl;
use crate::error;
use crate::error::io_eof;
use crate::iovalue;
use crate::owned;
use crate::shell;
use crate::reader::NextToken;
use super::constants::Tag;
@ -310,8 +306,8 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
}
}
fn value_clone(&self) -> PlainValue<'static, D> {
owned(View {
fn value_clone(&self) -> Value<D> {
Value::new(View {
repr: self.repr.trim(self.annotation_offset .. self.value_range.end),
annotation_offset: 0,
value_range: (self.value_range.start - self.annotation_offset
@ -348,22 +344,13 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
}
}
fn is_signed_integer(&self) -> bool {
fn as_signed_integer(&self) -> Option<Cow<'_, SignedInteger>> {
match self.tag() {
Tag::SmallInteger(_) => true,
Tag::MediumInteger(_) => true,
Tag::SignedInteger => true,
_ => false,
}
}
fn as_signed_integer(&self) -> Option<SignedInteger> {
match self.tag() {
Tag::SmallInteger(v) => Some(v.into()),
Tag::MediumInteger(n) => Some(self.signed_integer(self.value_range.start + 1, n as usize)),
Tag::SmallInteger(v) => Some(Cow::Owned(v.into())),
Tag::MediumInteger(n) => Some(Cow::Owned(self.signed_integer(self.value_range.start + 1, n as usize))),
Tag::SignedInteger => {
let (n, i) = self.varint();
Some(self.signed_integer(i, n as usize))
Some(Cow::Owned(self.signed_integer(i, n as usize)))
}
_ => None,
}
@ -400,9 +387,9 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
self.tag() == Tag::Record
}
fn label(&self) -> Value<'_, D> {
fn label(&self) -> Value<D> {
if !self.is_record() { panic!("Not a record") }
shell(View::inner_new(&self.repr, self.value_range.start + 1).unwrap())
Value::new(View::inner_new(&self.repr, self.value_range.start + 1).unwrap())
}
fn is_sequence(&self) -> bool {
@ -417,11 +404,11 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
}
}
fn index(&self, i: usize) -> Value<'_, D> {
fn index(&self, i: usize) -> Value<D> {
self.iter().nth(i).unwrap()
}
fn iter(&self) -> Box<dyn Iterator<Item = Value<'_, D>> + '_> {
fn iter(&self) -> Box<dyn Iterator<Item = Value<D>> + '_> {
let mut i = Box::new(ViewIterator::inner_new(&self.repr, self.value_range.start + 1));
match self.tag() {
Tag::Record => { i.next(); () }
@ -436,33 +423,29 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
self.tag() == Tag::Set
}
fn has(&self, v: &dyn ValueImpl<D>) -> bool {
self.iter().find(|e| v == &**e).is_some()
fn has(&self, v: &Value<D>) -> bool {
self.iter().find(|e| v == e).is_some()
}
fn is_dictionary(&self) -> bool {
self.tag() == Tag::Dictionary
}
fn get(&self, k: &dyn ValueImpl<D>) -> Option<Value<'_, D>> {
fn get(&self, k: &Value<D>) -> Option<Value<D>> {
for (kk, vv) in self.entries() {
if &*kk == k { return Some(vv); }
if k == &kk { return Some(vv); }
}
None
}
fn entries(&self) -> Box<dyn Iterator<Item = (Value<'_, D>, Value<'_, D>)> + '_> {
fn entries(&self) -> Box<dyn Iterator<Item = (Value<D>, Value<D>)> + '_> {
if !self.is_dictionary() { panic!("Not a dictionary") }
Box::new(DictionaryAdapter(ViewIterator::inner_new(&self.repr, self.value_range.start + 1)))
}
fn is_embedded(&self) -> bool {
self.tag() == Tag::Embedded
}
fn embedded(&self) -> Cow<'_, D> {
if !self.is_embedded() { panic!("Not an embedded value") }
match self.repr.index.embedded.as_ref() {
fn as_embedded(&self) -> Option<Cow<'_, D>> {
if self.tag() != Tag::Embedded { return None }
Some(match self.repr.index.embedded.as_ref() {
Some(e) => {
Cow::Borrowed(e.iter().find_map(|(r, d)| {
if r.start == self.value_range.start { Some(d) } else { None }
@ -475,7 +458,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
let d = D::Decode::default().decode_embedded(&mut r, true).unwrap();
Cow::Owned(d)
}
}
})
}
fn annotations(&self) -> Option<Cow<'_, [IOValue]>> {
@ -488,7 +471,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ValueImpl<D> for View<'de, Packe
phantom: PhantomData,
});
let anns: Vec<IOValue> = AnnotationAdapter(ViewIterator::inner_new(&repr, self.annotation_offset))
.map(|ann| iovalue(ann.into_owned()))
.map(|ann| ann.into())
.collect();
Some(Cow::Owned(anns))
}
@ -514,7 +497,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> ViewStream<'de, 'dec, D, Dec> {
}
impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> Iterator for ViewStream<'de, 'dec, D, Dec> {
type Item = io::Result<Value<'de, D>>;
type Item = io::Result<Value<D>>;
fn next(&mut self) -> Option<Self::Item> {
if self.offset >= self.buf.len() {
@ -523,7 +506,7 @@ impl<'de, 'dec, D: Domain, Dec: DomainDecode<D>> Iterator for ViewStream<'de, 'd
match View::new_offset(self.buf, self.dec.as_mut().map(|dec| &mut *dec), self.offset) {
Ok(v) => {
self.offset = v.value_range.end;
Some(Ok(shell(v)))
Some(Ok(Value::new(v)))
}
Err(e) => Some(Err(e)),
}
@ -543,7 +526,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> ViewIterator<IndexedRepr<'de, Pa
}
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<IndexedRepr<'de, Packed, D>> {
type Item = Value<'de, D>;
type Item = Value<D>;
fn next(&mut self) -> Option<Self::Item> {
if let Ok(Tag::End) = tag_at(self.repr.packed.as_ref(), self.offset) {
@ -551,7 +534,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<Indexe
} else {
let v = View::inner_new(&self.repr, self.offset).unwrap();
self.offset = v.value_range.end;
Some(shell(v))
Some(Value::new(v))
}
}
}
@ -559,7 +542,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for ViewIterator<Indexe
pub struct DictionaryAdapter<Repr>(pub ViewIterator<Repr>);
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for DictionaryAdapter<IndexedRepr<'de, Packed, D>> {
type Item = (Value<'de, D>, Value<'de, D>);
type Item = (Value<D>, Value<D>);
fn next(&mut self) -> Option<Self::Item> {
let k = self.0.next()?;
@ -571,7 +554,7 @@ impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for DictionaryAdapter<I
pub struct AnnotationAdapter<Repr>(pub ViewIterator<Repr>);
impl<'de, Packed: AsRef<[u8]> + 'de, D: Domain> Iterator for AnnotationAdapter<IndexedRepr<'de, Packed, D>> {
type Item = Value<'de, D>;
type Item = Value<D>;
fn next(&mut self) -> Option<Self::Item> {
if let Ok(Tag::Annotation) = tag_at(self.0.repr.packed.as_ref(), self.0.offset) {

21
implementations/rust/preserves/src/reader.rs
View File

@ -5,8 +5,8 @@ use std::marker::PhantomData;
use crate::BinarySource;
use crate::CompoundClass;
use crate::PlainValue;
use crate::SignedInteger;
use crate::Value;
use crate::ValueClass;
use crate::boundary as B;
use crate::domain::Domain;
@ -23,7 +23,6 @@ use crate::repr::Map;
use crate::repr::Record;
use crate::repr::Set;
use crate::repr::ValueImpl;
use crate::repr::owned;
pub type ReaderResult<T> = std::result::Result<T, Error>;
@ -144,11 +143,11 @@ pub trait Reader<'de> {
}
}
fn next<'produced: 'de, D: Domain, Dec: DomainDecode<D>>(
fn next<D: Domain, Dec: DomainDecode<D>>(
&mut self,
read_annotations: bool,
dec: &mut Dec,
) -> io::Result<PlainValue<'produced, D>>
) -> io::Result<Value<D>>
{
let (anns, v) = match read_annotations {
true => self.gather_annotations()?.ok_or_else(io_eof)?,
@ -161,7 +160,7 @@ pub trait Reader<'de> {
self.open_embedded()?;
let v = dec.decode_embedded(self, read_annotations)?;
self.close_embedded()?;
Box::new(Embedded::new(v))
Value::new(Embedded::new(v))
}
ValueClass::Compound(CompoundClass::Record) => {
let mut vs = Vec::new();
@ -172,7 +171,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::RecordField)? {
vs.push(self.next(read_annotations, dec)?);
}
Box::new(Record::_from_vec(vs))
Value::new(Record::_from_vec(vs))
}
ValueClass::Compound(CompoundClass::Sequence) => {
let mut vs = Vec::new();
@ -181,7 +180,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::SequenceValue)? {
vs.push(self.next(read_annotations, dec)?);
}
Box::new(vs)
Value::new(vs)
}
ValueClass::Compound(CompoundClass::Set) => {
let mut s = Set::new();
@ -190,7 +189,7 @@ pub trait Reader<'de> {
while !self.close_compound(&mut b, &B::Item::SetValue)? {
s.insert(self.next(read_annotations, dec)?);
}
Box::new(s)
Value::new(s)
}
ValueClass::Compound(CompoundClass::Dictionary) => {
let mut d = Map::new();
@ -202,13 +201,13 @@ pub trait Reader<'de> {
self.boundary(&b)?;
d.insert(k, self.next(read_annotations, dec)?);
}
Box::new(d)
Value::new(d)
}
};
if anns.is_empty() {
Ok(value)
} else {
Ok(owned(Annotations::new(value, anns)))
Ok(Annotations::new(value, anns))
}
}
@ -230,7 +229,7 @@ pub trait Reader<'de> {
}
fn next_signedinteger(&mut self) -> ReaderResult<SignedInteger> {
self.next_iovalue(false)?.as_signed_integer().ok_or(Error::Expected(ExpectedKind::SignedInteger))
Ok(self.next_iovalue(false)?.as_signed_integer().ok_or(Error::Expected(ExpectedKind::SignedInteger))?.into_owned().into())
}
fn next_i8(&mut self) -> ReaderResult<i8> { Ok(i8::try_from(&self.next_signedinteger()?)?) }

666
implementations/rust/preserves/src/repr.rs
View File

File diff suppressed because it is too large Load Diff

16
implementations/rust/preserves/src/text/mod.rs
View File

@ -11,13 +11,13 @@ use crate::BytesBinarySource;
use crate::Domain;
use crate::DomainDecode;
use crate::IOValue;
use crate::PlainValue;
use crate::Reader;
use crate::Value;
pub fn from_str<'de, D: Domain, Dec: DomainDecode<D>>(
s: &'de str,
decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> {
) -> io::Result<Value<D>> {
BytesBinarySource::new(s.as_bytes()).text().next(false, decode_embedded)
}
@ -28,7 +28,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
pub fn annotated_from_str<'de, D: Domain, Dec: DomainDecode<D>>(
s: &'de str,
decode_embedded: &mut Dec,
) -> io::Result<PlainValue<'de, D>> {
) -> io::Result<Value<D>> {
BytesBinarySource::new(s.as_bytes()).text().next(true, decode_embedded)
}
@ -39,16 +39,16 @@ pub fn annotated_iovalue_from_str(s: &str) -> io::Result<IOValue> {
#[cfg(test)]
mod formatting_tests {
use crate::IOValue;
use crate::Value;
use crate::test_domain::Dom;
use crate::ArcValue;
#[test] fn format_debug_and_parse() {
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<ArcValue<Dom>>().unwrap();
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
assert_eq!(format!("{:?}", &v), "[1, {a: #!\"One\", z: 2}, 3]");
}
#[test] fn format_pretty_debug_and_parse() {
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<ArcValue<Dom>>().unwrap();
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
assert_eq!(format!("{:#?}", &v), concat!(
"[\n",
" 1,\n",
@ -84,7 +84,7 @@ mod unusual_float_tests {
fn d32(u: u32, expected: &str) {
let v = f32::from_bits(u);
let w = iovalue(v);
let w = value(v).into();
assert_eq!(format!("{:?}", w), expected);
let x = expected.parse::<IOValue>().unwrap();
assert_eq!(x, w);
@ -92,7 +92,7 @@ mod unusual_float_tests {
fn d64(u: u64, expected: &str) {
let v = f64::from_bits(u);
let w = iovalue(v);
let w = value(v).into();
assert_eq!(format!("{:?}", w), expected);
let x = expected.parse::<IOValue>().unwrap();
assert_eq!(x, w);

7
implementations/rust/preserves/src/text/reader.rs
View File

@ -266,9 +266,10 @@ impl<'de, S: BinarySource<'de>> TextReader<'de, S>
return match NUMBER_RE.captures(&s) {
None => Ok(Atom::Symbol(s.into())),
Some(m) => match m.get(2) {
None => Ok(Atom::SignedInteger(s.parse::<BigInt>().map_err(
|_| self.syntax_error(&format!(
"Invalid signed-integer number: {:?}", s)))?.into())),
None => Ok(Atom::SignedInteger(Cow::Owned(
s.parse::<BigInt>().map_err(
|_| self.syntax_error(&format!(
"Invalid signed-integer number: {:?}", s)))?.into()))),
Some(_) => {
if let Some(maybe_f) = m.get(7) {
let s = m[1].to_owned() + &m[3];

6
implementations/rust/preserves/src/writer.rs
View File

@ -70,9 +70,9 @@ pub trait Writer {
fn specialized(&mut self) -> Option<(&str, &mut dyn io::Write)> { None }
}
pub fn write_value<D: Domain, V: ValueImpl<D>>(
pub fn write_value<D: Domain>(
w: &mut dyn Writer,
v: V,
v: &dyn ValueImpl<D>,
enc: &mut dyn DomainEncode<D>,
) -> io::Result<()> {
let annotations = v.annotations();
@ -163,7 +163,7 @@ pub fn write_value<D: Domain, V: ValueImpl<D>>(
}
ValueClass::Embedded => {
w.start_embedded()?;
enc.encode_embedded(w, &v.embedded())?;
enc.encode_embedded(w, &v.as_embedded().unwrap())?;
w.end_embedded()?
}
}