ehmry
/
preserves
forked from syndicate-lang/preserves
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

NestedValue::D --> NestedValue::Embedded

This commit is contained in:
Tony Garnock-Jones 2021-09-15 15:19:03 +02:00
parent 997bea2836
commit 06fc9aa017
9 changed files with 37 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
implementations/rust/preserves/src/value/packed/mod.rs
View File

@ -9,7 +9,7 @@ use std::io;
use super::{BinarySource, DomainDecode, IOValue, IOValueDomainCodec, NestedValue, Reader}; use super::{BinarySource, DomainDecode, IOValue, IOValueDomainCodec, NestedValue, Reader};
pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::D>>( pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
bs: &[u8], bs: &[u8],
decode_embedded: Dec, decode_embedded: Dec,
) -> io::Result<N> { ) -> io::Result<N> {
@ -20,7 +20,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result<IOValue> {
from_bytes(bs, IOValueDomainCodec) from_bytes(bs, IOValueDomainCodec)
} }
pub fn annotated_from_bytes<N: NestedValue, Dec: DomainDecode<N::D>>( pub fn annotated_from_bytes<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
bs: &[u8], bs: &[u8],
decode_embedded: Dec, decode_embedded: Dec,
) -> io::Result<N> { ) -> io::Result<N> {

8
implementations/rust/preserves/src/value/packed/reader.rs
View File

@ -30,13 +30,13 @@ use super::super::{
signed_integer::SignedInteger, signed_integer::SignedInteger,
}; };
pub struct PackedReader<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> { pub struct PackedReader<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>> {
pub source: &'src mut S, pub source: &'src mut S,
pub decode_embedded: Dec, pub decode_embedded: Dec,
phantom: PhantomData<&'de N>, phantom: PhantomData<&'de N>,
} }
impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>>
BinarySource<'de> BinarySource<'de>
for PackedReader<'de, 'src, N, Dec, S> for PackedReader<'de, 'src, N, Dec, S>
{ {
@ -65,7 +65,7 @@ fn out_of_range<I: Into<BigInt>>(i: I) -> error::Error {
error::Error::NumberOutOfRange(i.into()) error::Error::NumberOutOfRange(i.into())
} }
impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> PackedReader<'de, 'src, N, Dec, S> { impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>> PackedReader<'de, 'src, N, Dec, S> {
pub fn new(source: &'src mut S, decode_embedded: Dec) -> Self { pub fn new(source: &'src mut S, decode_embedded: Dec) -> Self {
PackedReader { source, decode_embedded, phantom: PhantomData } PackedReader { source, decode_embedded, phantom: PhantomData }
} }
@ -257,7 +257,7 @@ impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> P
} }
} }
impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::D>, S: BinarySource<'de>> impl<'de, 'src, N: NestedValue, Dec: DomainDecode<N::Embedded>, S: BinarySource<'de>>
Reader<'de, N> Reader<'de, N>
for PackedReader<'de, 'src, N, Dec, S> for PackedReader<'de, 'src, N, Dec, S>
{ {

2
implementations/rust/preserves/src/value/packed/writer.rs
View File

@ -16,7 +16,7 @@ use super::super::writer::{Writer, CompoundWriter, varint};
pub struct PackedWriter<W: io::Write>(Suspendable<W>); pub struct PackedWriter<W: io::Write>(Suspendable<W>);
impl PackedWriter<&mut Vec<u8>> { impl PackedWriter<&mut Vec<u8>> {
pub fn encode<N: NestedValue, Enc: DomainEncode<N::D>>( pub fn encode<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
enc: &mut Enc, enc: &mut Enc,
v: &N, v: &N,
) -> io::Result<Vec<u8>> { ) -> io::Result<Vec<u8>> {

8
implementations/rust/preserves/src/value/reader.rs
View File

@ -19,7 +19,7 @@ use super::signed_integer::SignedInteger;
pub type ReaderResult<T> = std::result::Result<T, error::Error>; pub type ReaderResult<T> = std::result::Result<T, error::Error>;
pub enum Token<N: NestedValue> { pub enum Token<N: NestedValue> {
Embedded(N::D), Embedded(N::Embedded),
Atom(N), Atom(N),
Compound(CompoundClass), Compound(CompoundClass),
End, End,
@ -229,7 +229,7 @@ pub trait BinarySource<'de>: Sized {
fn readbytes(&mut self, count: usize) -> io::Result<Cow<'de, [u8]>>; fn readbytes(&mut self, count: usize) -> io::Result<Cow<'de, [u8]>>;
fn readbytes_into(&mut self, bs: &mut [u8]) -> io::Result<()>; fn readbytes_into(&mut self, bs: &mut [u8]) -> io::Result<()>;
fn packed<N: NestedValue, Dec: DomainDecode<N::D>>( fn packed<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
&mut self, &mut self,
decode_embedded: Dec, decode_embedded: Dec,
) -> super::PackedReader<'de, '_, N, Dec, Self> { ) -> super::PackedReader<'de, '_, N, Dec, Self> {
@ -242,10 +242,10 @@ pub trait BinarySource<'de>: Sized {
self.packed(IOValueDomainCodec) self.packed(IOValueDomainCodec)
} }
fn text<N: NestedValue, Dec: DomainParse<N::D>>( fn text<N: NestedValue, Dec: DomainParse<N::Embedded>>(
&mut self, &mut self,
decode_embedded: Dec, decode_embedded: Dec,
) -> super::TextReader<'de, '_, N::D, Dec, Self> { ) -> super::TextReader<'de, '_, N::Embedded, Dec, Self> {
super::TextReader::new(self, decode_embedded) super::TextReader::new(self, decode_embedded)
} }

30
implementations/rust/preserves/src/value/repr.rs
View File

@ -26,13 +26,13 @@ impl<T> Embeddable for T where T: Domain + Clone {}
impl<D: Domain> Domain for Arc<D> {} impl<D: Domain> Domain for Arc<D> {}
pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord { pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
type D: Embeddable; type Embedded: Embeddable;
fn new<V>(v: V) -> Self where Value<Self>: From<V> { fn new<V>(v: V) -> Self where Value<Self>: From<V> {
Value::from(v).wrap() Value::from(v).wrap()
} }
fn domain<E>(e: E) -> Self where Self::D: From<E> { fn domain<E>(e: E) -> Self where Self::Embedded: From<E> {
Value::Embedded(e.into()).wrap() Value::Embedded(e.into()).wrap()
} }
@ -64,14 +64,14 @@ pub trait NestedValue: Sized + Debug + Clone + Eq + Hash + Ord {
fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<M, Err> fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<M, Err>
where where
F: FnMut(&Self::D) -> Result<Value<M>, Err> F: FnMut(&Self::Embedded) -> Result<Value<M>, Err>
{ {
Ok(M::wrap(self.annotations().copy_via(f)?, self.value().copy_via(f)?)) Ok(M::wrap(self.annotations().copy_via(f)?, self.value().copy_via(f)?))
} }
fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err> fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err>
where where
F: FnMut(&Self::D) -> Result<(), Err> F: FnMut(&Self::Embedded) -> Result<(), Err>
{ {
match &self.annotations().0 { match &self.annotations().0 {
None => (), None => (),
@ -95,7 +95,7 @@ pub enum Value<N: NestedValue> {
Sequence(Vec<N>), Sequence(Vec<N>),
Set(Set<N>), Set(Set<N>),
Dictionary(Map<N, N>), Dictionary(Map<N, N>),
Embedded(N::D), Embedded(N::Embedded),
} }
/// The kinds of `Value` from the specification. /// The kinds of `Value` from the specification.
@ -905,7 +905,7 @@ impl<N: NestedValue> Value<N> {
self.as_embedded().is_some() self.as_embedded().is_some()
} }
pub fn as_embedded(&self) -> Option<&N::D> { pub fn as_embedded(&self) -> Option<&N::Embedded> {
if let Value::Embedded(d) = self { if let Value::Embedded(d) = self {
Some(d) Some(d)
} else { } else {
@ -913,13 +913,13 @@ impl<N: NestedValue> Value<N> {
} }
} }
pub fn to_embedded(&self) -> Result<&N::D, Error> { pub fn to_embedded(&self) -> Result<&N::Embedded, Error> {
self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded)) self.as_embedded().ok_or_else(|| self.expected(ExpectedKind::Embedded))
} }
pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Value<M>, Err> pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Value<M>, Err>
where where
F: FnMut(&N::D) -> Result<Value<M>, Err> F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
{ {
Ok(match self { Ok(match self {
Value::Boolean(b) => Value::Boolean(*b), Value::Boolean(b) => Value::Boolean(*b),
@ -945,7 +945,7 @@ impl<N: NestedValue> Value<N> {
pub fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err> pub fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err>
where where
F: FnMut(&N::D) -> Result<(), Err> F: FnMut(&N::Embedded) -> Result<(), Err>
{ {
match self { match self {
Value::Boolean(_) | Value::Boolean(_) |
@ -1045,7 +1045,7 @@ impl<N: NestedValue> Annotations<N> {
pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Annotations<M>, Err> pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Annotations<M>, Err>
where where
F: FnMut(&N::D) -> Result<Value<M>, Err> F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
{ {
Ok(match &self.0 { Ok(match &self.0 {
None => None =>
@ -1109,7 +1109,7 @@ impl<D: Embeddable> PlainValue<D> {
} }
impl<D: Embeddable> NestedValue for PlainValue<D> { impl<D: Embeddable> NestedValue for PlainValue<D> {
type D = D; type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self { fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
PlainValue(AnnotatedValue::new(anns, v)) PlainValue(AnnotatedValue::new(anns, v))
@ -1147,7 +1147,7 @@ use std::rc::Rc;
pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>>>); pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>>>);
impl<D: Embeddable> NestedValue for RcValue<D> { impl<D: Embeddable> NestedValue for RcValue<D> {
type D = D; type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self { fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
RcValue(Rc::new(AnnotatedValue::new(anns, v))) RcValue(Rc::new(AnnotatedValue::new(anns, v)))
@ -1185,7 +1185,7 @@ impl<D: Embeddable> Debug for RcValue<D> {
pub struct ArcValue<D: Embeddable>(Arc<AnnotatedValue<ArcValue<D>>>); pub struct ArcValue<D: Embeddable>(Arc<AnnotatedValue<ArcValue<D>>>);
impl<D: Embeddable> NestedValue for ArcValue<D> { impl<D: Embeddable> NestedValue for ArcValue<D> {
type D = D; type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self { fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
ArcValue(Arc::new(AnnotatedValue::new(anns, v))) ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
@ -1226,7 +1226,7 @@ pub type UnwrappedIOValue = Value<IOValue>;
impl Domain for IOValue {} impl Domain for IOValue {}
impl NestedValue for IOValue { impl NestedValue for IOValue {
type D = Self; type Embedded = Self;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self { fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
IOValue(Arc::new(AnnotatedValue::new(anns, v))) IOValue(Arc::new(AnnotatedValue::new(anns, v)))
@ -1291,7 +1291,7 @@ impl<D: Embeddable> DummyValue<D> {
} }
impl<D: Embeddable> NestedValue for DummyValue<D> { impl<D: Embeddable> NestedValue for DummyValue<D> {
type D = D; type Embedded = D;
fn wrap(_anns: Annotations<Self>, _v: Value<Self>) -> Self { fn wrap(_anns: Annotations<Self>, _v: Value<Self>) -> Self {
DummyValue::new() DummyValue::new()

4
implementations/rust/preserves/src/value/text/mod.rs
View File

@ -10,7 +10,7 @@ use std::io;
use super::{DomainParse, IOValue, IOValueDomainCodec, NestedValue, Reader, ViaCodec}; use super::{DomainParse, IOValue, IOValueDomainCodec, NestedValue, Reader, ViaCodec};
pub fn from_str<N: NestedValue, Dec: DomainParse<N::D>>( pub fn from_str<N: NestedValue, Dec: DomainParse<N::Embedded>>(
s: &str, s: &str,
decode_embedded: Dec, decode_embedded: Dec,
) -> io::Result<N> { ) -> io::Result<N> {
@ -21,7 +21,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
from_str(s, ViaCodec::new(IOValueDomainCodec)) from_str(s, ViaCodec::new(IOValueDomainCodec))
} }
pub fn annotated_from_str<N: NestedValue, Dec: DomainParse<N::D>>( pub fn annotated_from_str<N: NestedValue, Dec: DomainParse<N::Embedded>>(
s: &str, s: &str,
decode_embedded: Dec, decode_embedded: Dec,
) -> io::Result<N> { ) -> io::Result<N> {

12
implementations/rust/preserves/src/value/text/reader.rs
View File

@ -89,14 +89,14 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
} }
// TODO: This is a duplicate of fn expected in PackedReader. // TODO: This is a duplicate of fn expected in PackedReader.
fn expected<N: NestedValue<D = D>>(&mut self, k: ExpectedKind) -> Error { fn expected<N: NestedValue<Embedded = D>>(&mut self, k: ExpectedKind) -> Error {
match Reader::<N>::demand_next(self, true) { match Reader::<N>::demand_next(self, true) {
Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))), Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))),
Err(e) => e.into() Err(e) => e.into()
} }
} }
fn gather_annotations<N: NestedValue<D = D>>(&mut self) -> ReaderResult<Vec<N>> { fn gather_annotations<N: NestedValue<Embedded = D>>(&mut self) -> ReaderResult<Vec<N>> {
let mut vs = Vec::new(); let mut vs = Vec::new();
loop { loop {
self.skip_whitespace(); self.skip_whitespace();
@ -334,7 +334,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
} }
} }
fn upto<N: NestedValue<D = D>>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result<Vec<N>> { fn upto<N: NestedValue<Embedded = D>>(&mut self, delimiter: u8, read_annotations: bool) -> io::Result<Vec<N>> {
let mut vs = Vec::new(); let mut vs = Vec::new();
loop { loop {
self.skip_whitespace(); self.skip_whitespace();
@ -346,7 +346,7 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
} }
} }
fn read_dictionary<N: NestedValue<D = D>>(&mut self, read_annotations: bool) -> io::Result<N> { fn read_dictionary<N: NestedValue<Embedded = D>>(&mut self, read_annotations: bool) -> io::Result<N> {
let mut d = Map::new(); let mut d = Map::new();
loop { loop {
self.skip_whitespace(); self.skip_whitespace();
@ -385,8 +385,8 @@ impl<'de, 'src, D: Embeddable, Dec: DomainParse<D>, S: BinarySource<'de>>
} }
} }
impl<'de, 'src, N: NestedValue, Dec: DomainParse<N::D>, S: BinarySource<'de>> impl<'de, 'src, N: NestedValue, Dec: DomainParse<N::Embedded>, S: BinarySource<'de>>
Reader<'de, N> for TextReader<'de, 'src, N::D, Dec, S> Reader<'de, N> for TextReader<'de, 'src, N::Embedded, Dec, S>
{ {
fn next(&mut self, read_annotations: bool) -> io::Result<Option<N>> { fn next(&mut self, read_annotations: bool) -> io::Result<Option<N>> {
self.skip_whitespace(); self.skip_whitespace();

2
implementations/rust/preserves/src/value/text/writer.rs
View File

@ -34,7 +34,7 @@ impl std::default::Default for CommaStyle {
} }
impl TextWriter<&mut Vec<u8>> { impl TextWriter<&mut Vec<u8>> {
pub fn encode<N: NestedValue, Enc: DomainEncode<N::D>>( pub fn encode<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
enc: &mut Enc, enc: &mut Enc,
v: &N, v: &N,
) -> io::Result<String> { ) -> io::Result<String> {

4
implementations/rust/preserves/src/value/writer.rs
View File

@ -58,7 +58,7 @@ pub trait Writer: Sized {
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
fn write<N: NestedValue, Enc: DomainEncode<N::D>>( fn write<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
&mut self, &mut self,
enc: &mut Enc, enc: &mut Enc,
v: &N, v: &N,
@ -86,7 +86,7 @@ pub trait Writer: Sized {
Ok(()) Ok(())
} }
fn write_value<N: NestedValue, Enc: DomainEncode<N::D>>( fn write_value<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
&mut self, &mut self,
enc: &mut Enc, enc: &mut Enc,
v: &Value<N>, v: &Value<N>,