A new approach to embedded-parameterised Reader

implementations/rust/preserves-schema/src/compiler/mod.rs

@@ -11,8 +11,9 @@ use crate::syntax::block::Formatter;
 use crate::syntax::block::constructors::*;
 
 use glob::glob;
+use preserves::value::BinarySource;
+use preserves::value::IOBinarySource;
 use preserves::value::Map;
-use preserves::value::PackedReader;
 use preserves::value::Reader;
 use preserves::value::Set;
 
@@ -54,7 +55,8 @@ impl CompilerConfig {
     pub fn load_schemas_and_bundles(&mut self, inputs: &Vec<PathBuf>) -> Result<(), Error> {
         for i in inputs {
             let mut f = File::open(&i)?;
-            let mut reader = PackedReader::decode_read(&mut f);
+            let mut src = IOBinarySource::new(&mut f);
+            let mut reader = src.packed_iovalues();
             let blob = reader.demand_next(false)?;
 
             if let Ok(s) = Schema::try_from(&blob) {

implementations/rust/preserves-schema/src/lib.rs

@@ -31,13 +31,14 @@ mod tests {
 
     #[test]
     fn metaschema_parsing() -> Result<(), std::io::Error> {
-        use preserves::value::{Reader, IOValue};
+        use preserves::value::{BinarySource, IOBinarySource, IOValue, Reader};
         use std::convert::TryFrom;
         use std::convert::From;
         use crate::gen::schema::*;
 
         let mut f = std::fs::File::open("../../../schema/schema.bin")?;
-        let mut reader = preserves::value::PackedReader::decode_read(&mut f);
+        let mut src = IOBinarySource::new(&mut f);
+        let mut reader = src.packed_iovalues();
         let schema = reader.demand_next(false)?;
         let parsed = Schema::try_from(&schema).expect("successful parse");
         assert_eq!(schema, IOValue::from(&parsed));

implementations/rust/preserves-schema/src/support/mod.rs

@@ -6,6 +6,7 @@ use preserves::value::Embeddable;
 use preserves::value::IOResult;
 use preserves::value::IOValue;
 use preserves::value::NestedValue;
+use preserves::value::NoEmbeddedDomainDecode;
 use preserves::value::Value;
 
 use std::convert::From;
@@ -13,9 +14,7 @@ use std::convert::TryFrom;
 use std::sync::Arc;
 
 pub fn decode_lit<D: Embeddable, N: NestedValue<D>>(bs: &[u8]) -> IOResult<N> {
-    preserves::value::packed::from_bytes(bs).unwrap().copy_via(
+    preserves::value::packed::from_bytes(bs, NoEmbeddedDomainDecode)
-        &mut |_| Err(std::io::Error::new(std::io::ErrorKind::Unsupported,
-                                         "Embedded values not supported in schema literals")))
 }
 
 pub fn decode_embedded<D: Domain>(

implementations/rust/preserves/Cargo.toml

@@ -15,7 +15,6 @@ gitlab = { repository = "preserves/preserves" }
 num = "0.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_bytes = "0.11"
-lazy_static = "1.4.0"
 
 [dev-dependencies]
 criterion = "0.3"

implementations/rust/preserves/examples/extensibility.rs

@@ -1,4 +1,4 @@
-use preserves::{de, value::{self, Reader, PackedReader}};
+use preserves::{de, value::{self, Reader, IOBinarySource, BinarySource}};
 use serde::{Serialize, Deserialize};
 use std::fs::File;
 use std::io::Error;
@@ -33,7 +33,7 @@ enum Variety {
 }
 
 fn try_file(kind: &str, path: &str) -> Result<(), Error> {
-    let fruits_value = PackedReader::decode_read(&mut File::open(path)?).demand_next(true)?;
+    let fruits_value = IOBinarySource::new(&mut File::open(path)?).packed_iovalues().demand_next(true)?;
     println!("{:?}", fruits_value);
 
     let fruits1: Vec<Fruit> = value::de::from_value(&fruits_value)?;

implementations/rust/preserves/src/de.rs

@@ -1,15 +1,17 @@
 use serde::Deserialize;
 use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
+
 use std::borrow::Cow;
 use std::marker::PhantomData;
-use super::value::PackedReader;
+
+use super::value::{IOValue, IOValueDomainDecode, PackedReader};
 use super::value::reader::{Reader, IOBinarySource, BytesBinarySource};
 
 pub use super::error::Error;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-pub struct Deserializer<'de, 'r, R: Reader<'de>> {
+pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue, IOValue>> {
     pub read: &'r mut R,
     phantom: PhantomData<&'de ()>,
 }
@@ -19,7 +21,7 @@ pub fn from_bytes<'de, T>(bytes: &'de [u8]) ->
 where
     T: Deserialize<'de>
 {
-    from_reader(&mut PackedReader::new(BytesBinarySource::new(bytes)))
+    from_reader(&mut PackedReader::new(&mut BytesBinarySource::new(bytes), IOValueDomainDecode))
 }
 
 pub fn from_read<'de, 'r, IOR: std::io::Read, T>(read: &'r mut IOR) ->
@@ -27,10 +29,10 @@ pub fn from_read<'de, 'r, IOR: std::io::Read, T>(read: &'r mut IOR) ->
 where
     T: Deserialize<'de>
 {
-    from_reader(&mut PackedReader::new(IOBinarySource::new(read)))
+    from_reader(&mut PackedReader::new(&mut IOBinarySource::new(read), IOValueDomainDecode))
 }
 
-pub fn from_reader<'r, 'de, R: Reader<'de>, T>(read: &'r mut R) ->
+pub fn from_reader<'r, 'de, R: Reader<'de, IOValue, IOValue>, T>(read: &'r mut R) ->
     Result<T>
 where
     T: Deserialize<'de>
@@ -40,13 +42,13 @@ where
     Ok(t)
 }
 
-impl<'r, 'de, R: Reader<'de>> Deserializer<'de, 'r, R> {
+impl<'r, 'de, R: Reader<'de, IOValue, 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>> serde::de::Deserializer<'de> for &'a mut Deserializer<'de, 'r, R>
+impl<'r, 'de, 'a, R: Reader<'de, IOValue, IOValue>> serde::de::Deserializer<'de> for &'a mut Deserializer<'de, 'r, R>
 {
     type Error = Error;
 
@@ -258,11 +260,11 @@ impl<'r, 'de, 'a, R: Reader<'de>> serde::de::Deserializer<'de> for &'a mut Deser
     }
 }
 
-pub struct Seq<'de, 'r, 'a, R: Reader<'de>> {
+pub struct Seq<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> {
     de: &'a mut Deserializer<'de, 'r, R>,
 }
 
-impl<'de, 'r, 'a, R: Reader<'de>> Seq<'de, 'r, 'a, R> {
+impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> Seq<'de, 'r, 'a, R> {
     fn new(de: &'a mut Deserializer<'de, 'r, R>) -> Self {
         Seq { de }
     }
@@ -281,7 +283,7 @@ impl<'de, 'r, 'a, R: Reader<'de>> Seq<'de, 'r, 'a, R> {
     }
 }
 
-impl<'de, 'r, 'a, R: Reader<'de>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> {
+impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> {
     type Error = Error;
 
     fn next_element_seed<T>(&mut self, seed: T) ->
@@ -291,7 +293,7 @@ impl<'de, 'r, 'a, R: Reader<'de>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> {
     }
 }
 
-impl<'de, 'r, 'a, R: Reader<'de>> MapAccess<'de> for Seq<'de, 'r, 'a, R> {
+impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> MapAccess<'de> for Seq<'de, 'r, 'a, R> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) ->
@@ -310,7 +312,7 @@ impl<'de, 'r, 'a, R: Reader<'de>> MapAccess<'de> for Seq<'de, 'r, 'a, R> {
     }
 }
 
-impl<'de, 'r, 'a, R: Reader<'de>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> {
+impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> {
     type Error = Error;
     type Variant = Seq<'de, 'r, 'a, R>;
 
@@ -323,7 +325,7 @@ impl<'de, 'r, 'a, R: Reader<'de>> EnumAccess<'de> for &'a mut Deserializer<'de,
     }
 }
 
-impl<'de, 'r, 'a, R: Reader<'de>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> {
+impl<'de, 'r, 'a, R: Reader<'de, IOValue, IOValue>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> {
     type Error = Error;
 
     fn unit_variant(mut self) -> Result<()> {

implementations/rust/preserves/src/lib.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate lazy_static;
-
 pub mod de;
 pub mod ser;
 pub mod error;
@@ -225,7 +222,7 @@ mod value_tests {
 
 #[cfg(test)]
 mod decoder_tests {
-    use crate::value::{Value, NestedValue, PackedReader, ConfiguredReader};
+    use crate::value::{Value, NestedValue, BinarySource, BytesBinarySource, ConfiguredReader};
     use crate::de::from_bytes;
     use crate::error::{Error, ExpectedKind, is_eof_io_error};
 
@@ -247,7 +244,8 @@ mod decoder_tests {
 
     #[test] fn skip_annotations_noskip() {
         let buf = &b"\x85\x92\x91"[..];
-        let mut d = ConfiguredReader::new(PackedReader::decode_bytes(&buf));
+        let mut src = BytesBinarySource::new(&buf);
+        let mut d = ConfiguredReader::new(src.packed_iovalues());
         let v = d.demand_next().unwrap();
         assert_eq!(v.annotations().slice().len(), 1);
         assert_eq!(v.annotations().slice()[0], Value::from(2).wrap());
@@ -256,7 +254,8 @@ mod decoder_tests {
 
     #[test] fn skip_annotations_skip() {
         let buf = &b"\x85\x92\x91"[..];
-        let mut d = ConfiguredReader::new(PackedReader::decode_bytes(&buf));
+        let mut src = BytesBinarySource::new(&buf);
+        let mut d = ConfiguredReader::new(src.packed_iovalues());
         d.set_read_annotations(false);
         let v = d.demand_next().unwrap();
         assert_eq!(v.annotations().slice().len(), 0);
@@ -266,7 +265,8 @@ mod decoder_tests {
     #[test] fn multiple_values_buf_advanced() {
         let buf = &b"\xb4\xb3\x04Ping\x84\xb4\xb3\x04Pong\x84"[..];
         assert_eq!(buf.len(), 16);
-        let mut d = ConfiguredReader::new(PackedReader::decode_bytes(&buf));
+        let mut src = BytesBinarySource::new(&buf);
+        let mut d = ConfiguredReader::new(src.packed_iovalues());
         assert_eq!(d.reader.source.index, 0);
         assert_eq!(d.demand_next().unwrap().value(), &Value::simple_record0("Ping"));
         assert_eq!(d.reader.source.index, 8);

implementations/rust/preserves/src/value/domain.rs

@@ -0,0 +1,24 @@
+use super::Embeddable;
+use super::IOResult;
+use super::IOValue;
+
+pub trait DomainDecode<D: Embeddable> {
+    fn decode_embedded_iovalue(&mut self, v: IOValue) -> IOResult<D>;
+}
+
+pub struct IOValueDomainDecode;
+
+impl DomainDecode<IOValue> for IOValueDomainDecode {
+    fn decode_embedded_iovalue(&mut self, v: IOValue) -> IOResult<IOValue> {
+        Ok(v)
+    }
+}
+
+pub struct NoEmbeddedDomainDecode;
+
+impl<D: Embeddable> DomainDecode<D> for NoEmbeddedDomainDecode {
+    fn decode_embedded_iovalue(&mut self, _v: IOValue) -> IOResult<D> {
+        Err(std::io::Error::new(std::io::ErrorKind::Unsupported,
+                                "Embedded values not supported here"))
+    }
+}

implementations/rust/preserves/src/value/mod.rs

@@ -1,4 +1,5 @@
 pub mod de;
+pub mod domain;
 pub mod magic;
 pub mod packed;
 pub mod reader;
@@ -9,9 +10,15 @@ pub mod writer;
 
 pub use de::Deserializer;
 pub use de::from_value;
+pub use domain::DomainDecode;
+pub use domain::IOValueDomainDecode;
+pub use domain::NoEmbeddedDomainDecode;
 pub use packed::PackedReader;
 pub use packed::PackedWriter;
+pub use reader::BinarySource;
+pub use reader::BytesBinarySource;
 pub use reader::ConfiguredReader;
+pub use reader::IOBinarySource;
 pub use reader::Reader;
 pub use repr::AnnotatedValue;
 pub use repr::ArcValue;
@@ -32,10 +39,6 @@ pub use ser::Serializer;
 pub use ser::to_value;
 pub use writer::Writer;
 
-pub use repr::FALSE;
-pub use repr::TRUE;
-pub use repr::EMPTY_SEQ;
-
 pub type IOResult<T> = std::result::Result<T, std::io::Error>;
 
 pub fn invert_map<A, B>(m: &Map<A, B>) -> Map<B, A>

implementations/rust/preserves/src/value/packed/mod.rs

@@ -5,12 +5,26 @@ pub mod writer;
 pub use reader::PackedReader;
 pub use writer::PackedWriter;
 
-use super::{Reader, IOValue, IOResult};
+use super::{BinarySource, DomainDecode, Embeddable, IOResult, IOValue, IOValueDomainDecode, NestedValue, Reader};
 
-pub fn from_bytes(bs: &[u8]) -> IOResult<IOValue> {
+pub fn from_bytes<D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>>(
-    PackedReader::decode_bytes(bs).demand_next(false)
+    bs: &[u8],
+    decode_embedded: Dec,
+) -> IOResult<N> {
+    super::BytesBinarySource::new(bs).packed(decode_embedded).demand_next(false)
 }
 
-pub fn annotated_from_bytes(bs: &[u8]) -> IOResult<IOValue> {
+pub fn iovalue_from_bytes(bs: &[u8]) -> IOResult<IOValue> {
-    PackedReader::decode_bytes(bs).demand_next(true)
+    from_bytes(bs, IOValueDomainDecode)
+}
+
+pub fn annotated_from_bytes<D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>>(
+    bs: &[u8],
+    decode_embedded: Dec,
+) -> IOResult<N> {
+    super::BytesBinarySource::new(bs).packed(decode_embedded).demand_next(true)
+}
+
+pub fn annotated_iovalue_from_bytes(bs: &[u8]) -> IOResult<IOValue> {
+    annotated_from_bytes(bs, IOValueDomainDecode)
 }

implementations/rust/preserves/src/value/packed/reader.rs

@@ -1,5 +1,8 @@
+use crate::error::{self, ExpectedKind, Received, is_eof_io_error, io_syntax_error};
+
 use num::bigint::BigInt;
 use num::traits::cast::{FromPrimitive, ToPrimitive};
+
 use std::borrow::Cow;
 use std::convert::TryFrom;
 use std::convert::TryInto;
@@ -7,21 +10,19 @@ use std::marker::PhantomData;
 
 use super::constants::Tag;
 use super::super::{
-    FALSE,
+    DomainDecode,
+    Embeddable,
     IOResult,
-    IOValue,
+    IOValueDomainDecode,
     Map,
     NestedValue,
     Record,
     Set,
-    TRUE,
     Value,
 
     reader::{
         BinarySource,
-        BytesBinarySource,
         ConfiguredReader,
-        IOBinarySource,
         Reader,
         ReaderResult,
     },
@@ -29,14 +30,16 @@ use super::super::{
     signed_integer::SignedInteger,
 };
 
-use crate::error::{self, ExpectedKind, Received, is_eof_io_error, io_syntax_error};
+pub struct PackedReader<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: BinarySource<'de>> {
-
+    pub source: &'src mut S,
-pub struct PackedReader<'de, S: BinarySource<'de>> {
+    pub decode_embedded: Dec,
-    pub source: S,
+    phantom: PhantomData<&'de (D, N)>,
-    phantom: PhantomData<&'de ()>,
 }
 
-impl<'de, S: BinarySource<'de>> BinarySource<'de> for PackedReader<'de, S> {
+impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: BinarySource<'de>>
+    BinarySource<'de>
+    for PackedReader<'de, 'src, D, N, Dec, S>
+{
     fn skip(&mut self) -> IOResult<()> {
         self.source.skip()
     }
@@ -55,21 +58,9 @@ fn out_of_range<I: Into<BigInt>>(i: I) -> error::Error {
     error::Error::NumberOutOfRange(i.into())
 }
 
-impl<'de> PackedReader<'de, BytesBinarySource<'de>> {
+impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: BinarySource<'de>> PackedReader<'de, 'src, D, N, Dec, S> {
-    pub fn decode_bytes(bytes: &'de [u8]) -> Self {
+    pub fn new(source: &'src mut S, decode_embedded: Dec) -> Self {
-        PackedReader::new(BytesBinarySource::new(bytes))
+        PackedReader { source, decode_embedded, phantom: PhantomData }
-    }
-}
-
-impl<'de, 'a, IOR: std::io::Read> PackedReader<'de, IOBinarySource<'a, IOR>> {
-    pub fn decode_read(read: &'a mut IOR) -> Self {
-        PackedReader::new(IOBinarySource::new(read))
-    }
-}
-
-impl<'de, S: BinarySource<'de>> PackedReader<'de, S> {
-    pub fn new(source: S) -> Self {
-        PackedReader { source, phantom: PhantomData }
     }
 
     fn read(&mut self) -> IOResult<u8> {
@@ -234,16 +225,19 @@ impl<'de, S: BinarySource<'de>> PackedReader<'de, S> {
     }
 }
 
-impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
+impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: BinarySource<'de>>
-    fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>> {
+    Reader<'de, D, N>
+    for PackedReader<'de, 'src, D, N, Dec, S>
+{
+    fn next(&mut self, read_annotations: bool) -> IOResult<Option<N>> {
         match self.peek() {
             Err(e) if is_eof_io_error(&e) => return Ok(None),
             Err(e) => return Err(e),
             Ok(_) => (),
         }
         Ok(Some(match Tag::try_from(self.read()?)? {
-            Tag::False => FALSE.clone(),
+            Tag::False => N::new(false),
-            Tag::True => TRUE.clone(),
+            Tag::True => N::new(true),
             Tag::Float => {
                 let mut bs = [0; 4];
                 self.readbytes_into(&mut bs)?;
@@ -263,7 +257,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
                     }
                     let (existing_annotations, v) = self.demand_next(read_annotations)?.pieces();
                     annotations.extend_from_slice(existing_annotations.slice());
-                    IOValue::wrap(Annotations::new(Some(annotations)), v)
+                    N::wrap(Annotations::new(Some(annotations)), v)
                 } else {
                     self.skip_value()?;
                     while Tag::try_from(self.peek()?)? == Tag::Annotation {
@@ -274,8 +268,8 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
                 }
             }
             Tag::Embedded => {
-                let v = self.demand_next(read_annotations)?;
+                let v = PackedReader::new(self.source, IOValueDomainDecode).demand_next(read_annotations)?;
-                Value::Embedded(v).wrap()
+                Value::Embedded(self.decode_embedded.decode_embedded_iovalue(v)?).wrap()
             }
             Tag::SmallInteger(v) => {
                 // TODO: prebuild these in value.rs
@@ -304,7 +298,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
             }
             Tag::Record => {
                 let iter = DelimitedStream { reader: self.configured(read_annotations) };
-                let vs = iter.collect::<IOResult<Vec<IOValue>>>()?;
+                let vs = iter.collect::<IOResult<Vec<N>>>()?;
                 if vs.is_empty() {
                     return Err(io_syntax_error("Too few elements in encoded record"))
                 }
@@ -312,7 +306,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
             }
             Tag::Sequence => {
                 let iter = DelimitedStream { reader: self.configured(read_annotations) };
-                let vs = iter.collect::<IOResult<Vec<IOValue>>>()?;
+                let vs = iter.collect::<IOResult<Vec<N>>>()?;
                 Value::Sequence(vs).wrap()
             }
             Tag::Set => {
@@ -450,13 +444,21 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
     }
 }
 
-struct DelimitedStream<'a, 'de, S: BinarySource<'de>> {
+struct DelimitedStream
-    reader: ConfiguredReader<'de, &'a mut PackedReader<'de, S>>,
+    <'a, 'de, 'src,
+     D: Embeddable,
+     N: NestedValue<D>,
+     Dec: DomainDecode<D>,
+     S: BinarySource<'de>>
+{
+    reader: ConfiguredReader<'de, D, N, &'a mut PackedReader<'de, 'src, D, N, Dec, S>>,
 }
 
-impl<'a, 'de, S: BinarySource<'de>> Iterator for DelimitedStream<'a, 'de, S>
+impl<'a, 'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: BinarySource<'de>>
+    Iterator
+    for DelimitedStream<'a, 'de, 'src, D, N, Dec, S>
 {
-    type Item = IOResult<IOValue>;
+    type Item = IOResult<N>;
     fn next(&mut self) -> Option<Self::Item> {
         match self.reader.reader.peekend() {
             Err(e) => Some(Err(e)),

implementations/rust/preserves/src/value/reader.rs

@@ -1,14 +1,15 @@
+use crate::error::{self, ExpectedKind, Received, io_eof};
+
 use std::borrow::Cow;
 use std::io::Read;
 use std::marker::PhantomData;
-use super::repr::{NestedValue, IOValue};
+
-use super::IOResult;
+use super::{DomainDecode, Embeddable, IOResult, IOValue, IOValueDomainDecode, NestedValue};
-use crate::error::{self, ExpectedKind, Received, io_eof};
 
 pub type ReaderResult<T> = std::result::Result<T, error::Error>;
 
-pub trait Reader<'de> {
+pub trait Reader<'de, D: Embeddable, N: NestedValue<D>> {
-    fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>>;
+    fn next(&mut self, read_annotations: bool) -> IOResult<Option<N>>;
     fn open_record(&mut self, arity: Option<usize>) -> ReaderResult<()>;
     fn open_sequence_or_set(&mut self) -> ReaderResult<()>;
     fn open_sequence(&mut self) -> ReaderResult<()>;
@@ -26,7 +27,7 @@ pub trait Reader<'de> {
         Ok(())
     }
 
-    fn demand_next(&mut self, read_annotations: bool) -> IOResult<IOValue> {
+    fn demand_next(&mut self, read_annotations: bool) -> IOResult<N> {
         self.next(read_annotations)?.ok_or_else(io_eof)
     }
 
@@ -81,7 +82,7 @@ pub trait Reader<'de> {
         }
     }
 
-    fn configured(self, read_annotations: bool) -> ConfiguredReader<'de, Self>
+    fn configured(self, read_annotations: bool) -> ConfiguredReader<'de, D, N, Self>
     where
         Self: std::marker::Sized
     {
@@ -116,8 +117,11 @@ pub trait Reader<'de> {
     }
 }
 
-impl<'r, 'de, R: Reader<'de>> Reader<'de> for &'r mut R {
+impl<'r, 'de, D: Embeddable, N: NestedValue<D>, R: Reader<'de, D, N>>
-    fn next(&mut self, read_annotations: bool) -> IOResult<Option<IOValue>> {
+    Reader<'de, D, N>
+    for &'r mut R
+{
+    fn next(&mut self, read_annotations: bool) -> IOResult<Option<N>> {
         (*self).next(read_annotations)
     }
 
@@ -155,11 +159,24 @@ impl<'r, 'de, R: Reader<'de>> Reader<'de> for &'r mut R {
 }
 
 
-pub trait BinarySource<'de> {
+pub trait BinarySource<'de>: Sized {
     fn skip(&mut self) -> IOResult<()>;
     fn peek(&mut self) -> IOResult<u8>;
     fn readbytes(&mut self, count: usize) -> IOResult<Cow<'de, [u8]>>;
     fn readbytes_into(&mut self, bs: &mut [u8]) -> IOResult<()>;
+
+    fn packed<D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>>(
+        &mut self,
+        decode_embedded: Dec,
+    ) -> super::PackedReader<'de, '_, D, N, Dec, Self> {
+        super::PackedReader::new(self, decode_embedded)
+    }
+
+    fn packed_iovalues(&mut self) ->
+        super::PackedReader<'de, '_, IOValue, IOValue, IOValueDomainDecode, Self>
+    {
+        self.packed(IOValueDomainDecode)
+    }
 }
 
 pub struct IOBinarySource<'a, R: Read> {
@@ -258,13 +275,13 @@ impl<'de> BinarySource<'de> for BytesBinarySource<'de> {
     }
 }
 
-pub struct ConfiguredReader<'de, R: Reader<'de>> {
+pub struct ConfiguredReader<'de, D: Embeddable, N: NestedValue<D>, R: Reader<'de, D, N>> {
     pub reader: R,
     pub read_annotations: bool,
-    phantom: PhantomData<&'de ()>,
+    phantom: PhantomData<&'de (D, N)>,
 }
 
-impl<'de, R: Reader<'de>> ConfiguredReader<'de, R> {
+impl<'de, D: Embeddable, N: NestedValue<D>, R: Reader<'de, D, N>> ConfiguredReader<'de, D, N, R> {
     pub fn new(reader: R) -> Self {
         reader.configured(true)
     }
@@ -273,13 +290,16 @@ impl<'de, R: Reader<'de>> ConfiguredReader<'de, R> {
         self.read_annotations = read_annotations
     }
 
-    pub fn demand_next(&mut self) -> IOResult<IOValue> {
+    pub fn demand_next(&mut self) -> IOResult<N> {
         self.reader.demand_next(self.read_annotations)
     }
 }
 
-impl<'de, R: Reader<'de>> std::iter::Iterator for ConfiguredReader<'de, R> {
+impl<'de, D: Embeddable, N: NestedValue<D>, R: Reader<'de, D, N>>
-    type Item = IOResult<IOValue>;
+    std::iter::Iterator
+    for ConfiguredReader<'de, D, N, R>
+{
+    type Item = IOResult<N>;
     fn next(&mut self) -> Option<Self::Item> {
         match self.reader.next(self.read_annotations) {
             Err(e) => Some(Err(e)),

implementations/rust/preserves/src/value/repr.rs

@@ -1046,12 +1046,6 @@ impl<D: Embeddable> Debug for ArcValue<D> {
 pub struct IOValue(Arc<AnnotatedValue<IOValue, IOValue>>);
 pub type UnwrappedIOValue = Value<IOValue, IOValue>;
 
-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<IOValue> for IOValue {

implementations/rust/preserves/tests/samples_tests.rs

@@ -1,7 +1,9 @@
 use preserves::error::{is_eof_io_error, is_syntax_io_error};
 use preserves::symbol::Symbol;
+use preserves::value::BinarySource;
+use preserves::value::BytesBinarySource;
+use preserves::value::IOBinarySource;
 use preserves::value::IOValue;
-use preserves::value::PackedReader;
 use preserves::value::PackedWriter;
 use preserves::value::Reader;
 use preserves::value::de::from_value as deserialize_from_value;
@@ -11,12 +13,13 @@ mod samples;
 use samples::*;
 
 fn decode_all(bytes: &'_ [u8]) -> Result<Vec<IOValue>, std::io::Error> {
-    PackedReader::decode_bytes(bytes).configured(true).collect()
+    BytesBinarySource::new(bytes).packed_iovalues().configured(true).collect()
 }
 
 #[test] fn run() -> std::io::Result<()> {
     let mut fh = std::fs::File::open("../../../tests/samples.bin").unwrap();
-    let mut d = PackedReader::decode_read(&mut fh).configured(true);
+    let mut src = IOBinarySource::new(&mut fh);
+    let mut d = src.packed_iovalues().configured(true);
     let tests: TestCases = deserialize_from_value(&d.next().unwrap().unwrap()).unwrap();
     // println!("{:#?}", tests);
 
@@ -55,14 +58,14 @@ fn decode_all(bytes: &'_ [u8]) -> Result<Vec<IOValue>, std::io::Error> {
                 }
             }
             TestCase::DecodeShort(ref bin) => {
-                assert!(if let Err(e) = PackedReader::decode_bytes(bin).configured(true).next().unwrap() {
+                assert!(if let Err(e) = BytesBinarySource::new(bin).packed_iovalues().configured(true).next().unwrap() {
                     is_eof_io_error(&e)
                 } else {
                     false
                 })
             }
             TestCase::DecodeEOF(ref bin) => {
-                assert!(PackedReader::decode_bytes(bin).configured(true).next().is_none());
+                assert!(BytesBinarySource::new(bin).packed_iovalues().configured(true).next().is_none());
             }
         }
     }