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};
pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::D>>(
pub fn from_bytes<N: NestedValue, Dec: DomainDecode<N::Embedded>>(
bs: &[u8],
decode_embedded: Dec,
) -> io::Result<N> {
@ -20,7 +20,7 @@ pub fn iovalue_from_bytes(bs: &[u8]) -> io::Result<IOValue> {
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],
decode_embedded: Dec,
) -> io::Result<N> {

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

@ -30,13 +30,13 @@ use super::super::{
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 decode_embedded: Dec,
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>
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())
}
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 {
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>
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>);
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,
v: &N,
) -> 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 enum Token<N: NestedValue> {
Embedded(N::D),
Embedded(N::Embedded),
Atom(N),
Compound(CompoundClass),
End,
@ -229,7 +229,7 @@ pub trait BinarySource<'de>: Sized {
fn readbytes(&mut self, count: usize) -> io::Result<Cow<'de, [u8]>>;
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,
decode_embedded: Dec,
) -> super::PackedReader<'de, '_, N, Dec, Self> {
@ -242,10 +242,10 @@ pub trait BinarySource<'de>: Sized {
self.packed(IOValueDomainCodec)
}
fn text<N: NestedValue, Dec: DomainParse<N::D>>(
fn text<N: NestedValue, Dec: DomainParse<N::Embedded>>(
&mut self,
decode_embedded: Dec,
) -> super::TextReader<'de, '_, N::D, Dec, Self> {
) -> super::TextReader<'de, '_, N::Embedded, Dec, Self> {
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> {}
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> {
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()
}
@ -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>
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)?))
}
fn foreach_embedded<F, Err>(&self, f: &mut F) -> Result<(), Err>
where
F: FnMut(&Self::D) -> Result<(), Err>
F: FnMut(&Self::Embedded) -> Result<(), Err>
{
match &self.annotations().0 {
None => (),
@ -95,7 +95,7 @@ pub enum Value<N: NestedValue> {
Sequence(Vec<N>),
Set(Set<N>),
Dictionary(Map<N, N>),
Embedded(N::D),
Embedded(N::Embedded),
}
/// The kinds of `Value` from the specification.
@ -905,7 +905,7 @@ impl<N: NestedValue> Value<N> {
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 {
Some(d)
} 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))
}
pub fn copy_via<M: NestedValue, F, Err>(&self, f: &mut F) -> Result<Value<M>, Err>
where
F: FnMut(&N::D) -> Result<Value<M>, Err>
F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
{
Ok(match self {
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>
where
F: FnMut(&N::D) -> Result<(), Err>
F: FnMut(&N::Embedded) -> Result<(), Err>
{
match self {
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>
where
F: FnMut(&N::D) -> Result<Value<M>, Err>
F: FnMut(&N::Embedded) -> Result<Value<M>, Err>
{
Ok(match &self.0 {
None =>
@ -1109,7 +1109,7 @@ impl<D: Embeddable> PlainValue<D> {
}
impl<D: Embeddable> NestedValue for PlainValue<D> {
type D = D;
type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
PlainValue(AnnotatedValue::new(anns, v))
@ -1147,7 +1147,7 @@ use std::rc::Rc;
pub struct RcValue<D: Embeddable>(Rc<AnnotatedValue<RcValue<D>>>);
impl<D: Embeddable> NestedValue for RcValue<D> {
type D = D;
type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
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>>>);
impl<D: Embeddable> NestedValue for ArcValue<D> {
type D = D;
type Embedded = D;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
ArcValue(Arc::new(AnnotatedValue::new(anns, v)))
@ -1226,7 +1226,7 @@ pub type UnwrappedIOValue = Value<IOValue>;
impl Domain for IOValue {}
impl NestedValue for IOValue {
type D = Self;
type Embedded = Self;
fn wrap(anns: Annotations<Self>, v: Value<Self>) -> Self {
IOValue(Arc::new(AnnotatedValue::new(anns, v)))
@ -1291,7 +1291,7 @@ impl<D: Embeddable> DummyValue<D> {
}
impl<D: Embeddable> NestedValue for DummyValue<D> {
type D = D;
type Embedded = D;
fn wrap(_anns: Annotations<Self>, _v: Value<Self>) -> Self {
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};
pub fn from_str<N: NestedValue, Dec: DomainParse<N::D>>(
pub fn from_str<N: NestedValue, Dec: DomainParse<N::Embedded>>(
s: &str,
decode_embedded: Dec,
) -> io::Result<N> {
@ -21,7 +21,7 @@ pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
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,
decode_embedded: Dec,
) -> 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.
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) {
Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))),
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();
loop {
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();
loop {
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();
loop {
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>>
Reader<'de, N> for TextReader<'de, 'src, N::D, Dec, S>
impl<'de, 'src, N: NestedValue, Dec: DomainParse<N::Embedded>, S: BinarySource<'de>>
Reader<'de, N> for TextReader<'de, 'src, N::Embedded, Dec, S>
{
fn next(&mut self, read_annotations: bool) -> io::Result<Option<N>> {
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>> {
pub fn encode<N: NestedValue, Enc: DomainEncode<N::D>>(
pub fn encode<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
enc: &mut Enc,
v: &N,
) -> 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,
enc: &mut Enc,
v: &N,
@ -86,7 +86,7 @@ pub trait Writer: Sized {
Ok(())
}
fn write_value<N: NestedValue, Enc: DomainEncode<N::D>>(
fn write_value<N: NestedValue, Enc: DomainEncode<N::Embedded>>(
&mut self,
enc: &mut Enc,
v: &Value<N>,