14775473202

Committed 01 May 2025 12:37PM UTC coverage: 76.018% (-1.6%) from 77.667%

Build # 14775473202

Build Type

Pull #221

github

Committed by

web-flow

Commit Message

Merge ca4cd1402 into e15d5670f

Pull Request Pull Request #221: Hello world

Run Details

292 of 372 new or added lines in 9 files covered. (78.49%)

36 existing lines in 7 files now uncovered.

3956 of 5204 relevant lines covered (76.02%)

1811.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.09

/lambda/src/expressions.rs

use crate::types::Name;
use astraea::tree::{BlobDigest, HashedValue, ReferenceIndex, Value, ValueDeserializationError};
use astraea::{
    storage::{LoadValue, StoreError, StoreValue},
    tree::ValueBlob,
};
use serde::{Deserialize, Serialize};
use std::fmt::Display;
use std::future::Future;
use std::hash::Hash;
use std::{
    collections::{BTreeMap, BTreeSet},
    pin::Pin,
    sync::Arc,
};

pub trait PrintExpression {
    fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result;
}

#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Clone, Serialize, Deserialize)]
pub enum Expression<E, V>
where
    E: Clone + Display + PrintExpression,
    V: Clone + Display,
{
    Unit,
    Literal(V),
    Apply { callee: E, argument: E },
    ReadVariable(Name),
    Lambda { parameter_name: Name, body: E },
    Construct(Vec<E>),
}

impl<E, V> PrintExpression for Expression<E, V>
where
    E: Clone + Display + PrintExpression,
    V: Clone + Display,
{
    fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {
        match self {
            Expression::Unit => write!(writer, "()"),
            Expression::Literal(literal_value) => {
                write!(writer, "literal({})", literal_value)
            }
            Expression::Apply { callee, argument } => {
                callee.print(writer, level)?;
                write!(writer, "(")?;
                argument.print(writer, level)?;
                write!(writer, ")")
            }
            Expression::ReadVariable(name) => {
                write!(writer, "{}", &name.key)
            }
            Expression::Lambda {
                parameter_name,
                body,
            } => {
                write!(writer, "({}) =>\n", parameter_name)?;
                let indented = level + 1;
                for _ in 0..(indented * 2) {
                    write!(writer, " ")?;
                }
                body.print(writer, indented)
            }
            Expression::Construct(arguments) => {
                write!(writer, "construct(")?;
                for argument in arguments {
                    argument.print(writer, level)?;
                    write!(writer, ", ")?;
                }
                write!(writer, ")")
            }
        }
    }
}

impl<E, V> Expression<E, V>
where
    E: Clone + Display + PrintExpression,
    V: Clone + Display,
{
    pub fn to_string(&self) -> String {
        let mut result = String::new();
        self.print(&mut result, 0).unwrap();
        result
    }

    pub fn make_unit() -> Self {
        Expression::Unit
    }

    pub fn make_literal(value: V) -> Self {
        Expression::Literal(value)
    }

    pub fn make_apply(callee: E, argument: E) -> Self {
        Expression::Apply { callee, argument }
    }

    pub fn make_lambda(parameter_name: Name, body: E) -> Self {
        Expression::Lambda {
            parameter_name,
            body,
        }
    }

    pub fn make_construct(arguments: Vec<E>) -> Self {
        Expression::Construct(arguments)
    }

    pub async fn map_child_expressions<
        't,
        Expr: Clone + Display + PrintExpression,
        V2: Clone + Display,
        Error,
        F,
        G,
    >(
        &self,
        transform_expression: &'t F,
        transform_value: &'t G,
    ) -> Result<Expression<Expr, V2>, Error>
    where
        F: Fn(&E) -> Pin<Box<dyn Future<Output = Result<Expr, Error>> + 't>>,
        G: Fn(&V) -> Pin<Box<dyn Future<Output = Result<V2, Error>> + 't>>,
    {
        match self {
            Expression::Unit => Ok(Expression::Unit),
            Expression::Literal(value) => Ok(Expression::Literal(transform_value(value).await?)),
            Expression::Apply { callee, argument } => Ok(Expression::Apply {
                callee: transform_expression(callee).await?,
                argument: transform_expression(argument).await?,
            }),
            Expression::ReadVariable(name) => Ok(Expression::ReadVariable(name.clone())),
            Expression::Lambda {
                parameter_name,
                body,
            } => Ok(Expression::Lambda {
                parameter_name: parameter_name.clone(),
                body: transform_expression(body).await?,
            }),
            Expression::Construct(items) => {
                let mut transformed_items = Vec::new();
                for item in items.iter() {
                    transformed_items.push(transform_expression(item).await?);
                }
                Ok(Expression::Construct(transformed_items))
            }
        }
    }
}

impl<E, V> Display for Expression<E, V>
where
    E: Clone + Display + PrintExpression,
    V: Clone + Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.print(f, 0)
    }
}

#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Clone)]
pub struct DeepExpression(pub Expression<Arc<DeepExpression>, BlobDigest>);

impl PrintExpression for DeepExpression {
    fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {
        self.0.print(writer, level)
    }
}

impl PrintExpression for Arc<DeepExpression> {
    fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {
        self.0.print(writer, level)
    }
}

impl Display for DeepExpression {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

pub type ShallowExpression = Expression<BlobDigest, BlobDigest>;

impl PrintExpression for BlobDigest {
    fn print(&self, writer: &mut dyn std::fmt::Write, _level: usize) -> std::fmt::Result {
        write!(writer, "{}", self)
    }
}

pub type ReferenceExpression = Expression<ReferenceIndex, ReferenceIndex>;

impl PrintExpression for ReferenceIndex {
    fn print(&self, writer: &mut dyn std::fmt::Write, _level: usize) -> std::fmt::Result {
        write!(writer, "{}", self)
    }
}

pub fn to_reference_expression(
    expression: &ShallowExpression,
) -> (ReferenceExpression, Vec<BlobDigest>) {
    match expression {
        Expression::Unit => (ReferenceExpression::Unit, vec![]),
        Expression::Literal(value) => (
            ReferenceExpression::Literal(ReferenceIndex(0)),
            vec![*value],
        ),
        Expression::Apply { callee, argument } => (
            ReferenceExpression::Apply {
                callee: ReferenceIndex(0),
                argument: ReferenceIndex(1),
            },
            // TODO: deduplicate?
            vec![*callee, *argument],
        ),
        Expression::ReadVariable(name) => (ReferenceExpression::ReadVariable(name.clone()), vec![]),
        Expression::Lambda {
            parameter_name,
            body,
        } => (
            ReferenceExpression::Lambda {
                parameter_name: parameter_name.clone(),
                body: ReferenceIndex(0),
            },
            vec![*body],
        ),
        Expression::Construct(items) => (
            ReferenceExpression::Construct(
                (0..items.len())
                    .map(|index| ReferenceIndex(index as u64))
                    .collect(),
            ),
            // TODO: deduplicate?
            items.clone(),
        ),
    }
}

pub async fn deserialize_shallow(value: &Value) -> Result<ShallowExpression, ()> {
    let reference_expression: ReferenceExpression = postcard::from_bytes(value.blob().as_slice())
        .unwrap(/*TODO*/);
    reference_expression
        .map_child_expressions(
            &|child: &ReferenceIndex| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {
                let child = value.references()[child.0 as usize].clone();
                Box::pin(async move { Ok(child) })
            },
            &|child: &ReferenceIndex| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {
                let child = value.references()[child.0 as usize].clone();
                Box::pin(async move { Ok(child) })
            },
        )
        .await
}

pub async fn deserialize_recursively(
    root: &BlobDigest,
    load_value: &(dyn LoadValue + Sync),
) -> Result<DeepExpression, ()> {
    let root_loaded = load_value.load_value(root).await.unwrap(/*TODO*/).hash().unwrap(/*TODO*/);
    let shallow = deserialize_shallow(&root_loaded.value()).await?;
    let deep = shallow
        .map_child_expressions(
            &|child: &BlobDigest| -> Pin<Box<dyn Future<Output = Result<Arc<DeepExpression>, ()>>>> {
                let child = child.clone();
                Box::pin(async move { deserialize_recursively(&child, load_value)
                    .await
                    .map(|success| Arc::new(success)) })
            },
            &|child: &BlobDigest| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {
                let child = child.clone();
                Box::pin(async move { Ok(child) })
            },
        )
        .await?;
    Ok(DeepExpression(deep))
}

pub fn expression_to_value(expression: &ShallowExpression) -> Value {
    let (reference_expression, references) = to_reference_expression(expression);
    let blob = postcard::to_allocvec(&reference_expression).unwrap(/*TODO*/);
    Value::new(
        ValueBlob::try_from(bytes::Bytes::from_owner(blob)).unwrap(/*TODO*/),
        references,
    )
}

pub async fn serialize_shallow(
    expression: &ShallowExpression,
    storage: &(dyn StoreValue + Sync),
) -> std::result::Result<BlobDigest, StoreError> {
    let value = expression_to_value(expression);
    storage
        .store_value(&HashedValue::from(Arc::new(value)))
        .await
}

pub async fn serialize_recursively(
    expression: &DeepExpression,
    storage: &(dyn StoreValue + Sync),
) -> std::result::Result<BlobDigest, StoreError> {
    let shallow_expression: ShallowExpression = expression
        .0
        .map_child_expressions(&|child: &Arc<DeepExpression>| -> Pin<
            Box<dyn Future<Output = Result<BlobDigest, StoreError>>>,
        > {
            let child = child.clone();
            Box::pin(async move {
                serialize_recursively(&child, storage)
                    .await
            })
        },&|child: &BlobDigest| -> Pin<
        Box<dyn Future<Output = Result<BlobDigest, StoreError>>>,
        > {
            let child = child.clone();
            Box::pin(async move {
                Ok(child)
            })
        })
        .await?;
    serialize_shallow(&shallow_expression, storage).await
}

#[derive(Debug)]
pub struct Closure {
    parameter_name: Name,
    body: Arc<DeepExpression>,
    captured_variables: BTreeMap<Name, BlobDigest>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ClosureBlob {
    parameter_name: Name,
    captured_variables: BTreeMap<Name, ReferenceIndex>,
}

impl ClosureBlob {
    pub fn new(parameter_name: Name, captured_variables: BTreeMap<Name, ReferenceIndex>) -> Self {
        Self {
            parameter_name,
            captured_variables,
        }
    }
}

impl Closure {
    pub fn new(
        parameter_name: Name,
        body: Arc<DeepExpression>,
        captured_variables: BTreeMap<Name, BlobDigest>,
    ) -> Self {
        Self {
            parameter_name,
            body,
            captured_variables,
        }
    }

    pub async fn serialize(
        &self,
        store_value: &(dyn StoreValue + Sync),
    ) -> Result<BlobDigest, StoreError> {
        let mut references = vec![serialize_recursively(&self.body, store_value).await?];
        let mut captured_variables = BTreeMap::new();
        for (name, reference) in self.captured_variables.iter() {
            let index = ReferenceIndex(references.len() as u64);
            captured_variables.insert(name.clone(), index);
            references.push(reference.clone());
        }
        let closure_blob = ClosureBlob::new(self.parameter_name.clone(), captured_variables);
        let closure_blob_bytes = postcard::to_allocvec(&closure_blob).unwrap(/*TODO*/);
        store_value
            .store_value(&HashedValue::from(Arc::new(Value::new(
                ValueBlob::try_from(bytes::Bytes::from_owner(closure_blob_bytes)).unwrap(/*TODO*/),
                references,
            ))))
            .await
    }

    pub async fn deserialize(
        root: &BlobDigest,
        load_value: &(dyn LoadValue + Sync),
    ) -> Result<Closure, ValueDeserializationError> {
        let loaded_root = match load_value.load_value(root).await {
            Some(success) => success,
            None => return Err(ValueDeserializationError::BlobUnavailable(root.clone())),
        };
        let root_value = loaded_root.hash().unwrap(/*TODO*/).value().clone();
        let closure_blob: ClosureBlob = match postcard::from_bytes(&root_value.blob().as_slice()) {
            Ok(success) => success,
            Err(error) => return Err(ValueDeserializationError::Postcard(error)),
        };
        let body_reference = &root_value.references()[0];
        let body = deserialize_recursively(body_reference, load_value).await.unwrap(/*TODO*/);
        let mut captured_variables = BTreeMap::new();
        for (name, index) in closure_blob.captured_variables {
            let reference = &root_value.references()[index.0 as usize];
            captured_variables.insert(name, reference.clone());
        }
        Ok(Closure::new(
            closure_blob.parameter_name,
            Arc::new(body),
            captured_variables,
        ))
    }
}

async fn call_method(
    parameter_name: &Name,
    captured_variables: &BTreeMap<Name, BlobDigest>,
    body: &DeepExpression,
    argument: &BlobDigest,
    load_value: &(dyn LoadValue + Sync),
    store_value: &(dyn StoreValue + Sync),
    read_variable: &Arc<ReadVariable>,
) -> std::result::Result<BlobDigest, StoreError> {
    let read_variable_in_body: Arc<ReadVariable> = Arc::new({
        let parameter_name = parameter_name.clone();
        let argument = argument.clone();
        let captured_variables = captured_variables.clone();
        let read_variable = read_variable.clone();
        move |name: &Name| -> Pin<Box<dyn core::future::Future<Output = BlobDigest> + Send>> {
            if name == &parameter_name {
                let argument = argument.clone();
                Box::pin(core::future::ready(argument))
            } else if let Some(found) = captured_variables.get(name) {
                Box::pin(core::future::ready(found.clone()))
            } else {
                read_variable(name)
            }
        }
    });
    Box::pin(evaluate(
        &body,
        load_value,
        store_value,
        &read_variable_in_body,
    ))
    .await
}

#[derive(Debug, Clone)]
pub struct InMemoryValue {
    pub blob: ValueBlob,
    pub references: Vec<Pointer>,
}

impl InMemoryValue {
    pub fn new(blob: ValueBlob, references: Vec<Pointer>) -> Self {
        Self { blob, references }
    }
}

#[derive(Debug, Clone)]
pub enum Pointer {
    Value(HashedValue),
    Reference(BlobDigest),
    InMemoryValue(InMemoryValue),
}

impl Pointer {
    pub fn serialize(self) -> HashedValue {
        match self {
            Pointer::Value(hashed_value) => hashed_value,
            Pointer::Reference(_blob_digest) => todo!(),
            Pointer::InMemoryValue(_in_memory_value) => {
                todo!()
            }
        }
    }

    pub async fn serialize_to_flat_value(&self) -> Option<Arc<Value>> {
        match self {
            Pointer::Value(hashed_value) => {
                if hashed_value.value().references().is_empty() {
                    Some(hashed_value.value().clone())
                } else {
                    None
                }
            }
            Pointer::Reference(_blob_digest) => todo!(),
            Pointer::InMemoryValue(_in_memory_value) => {
                todo!()
            }
        }
    }
}

pub type ReadVariable =
    dyn Fn(&Name) -> Pin<Box<dyn core::future::Future<Output = BlobDigest> + Send>> + Send + Sync;

fn find_captured_names(expression: &DeepExpression) -> BTreeSet<Name> {
    match &expression.0 {
        Expression::Unit => BTreeSet::new(),
        Expression::Literal(_blob_digest) => BTreeSet::new(),
        Expression::Apply { callee, argument } => {
            let mut result = find_captured_names(callee);
            result.append(&mut find_captured_names(argument));
            result
        }
        Expression::ReadVariable(name) => BTreeSet::from([name.clone()]),
        Expression::Lambda {
            parameter_name,
            body,
        } => {
            let mut result = find_captured_names(body);
            result.remove(&parameter_name);
            result
        }
        Expression::Construct(arguments) => {
            let mut result = BTreeSet::new();
            for argument in arguments {
                result.append(&mut find_captured_names(argument));
            }
            result
        }
    }
}

pub async fn evaluate(
    expression: &DeepExpression,
    load_value: &(dyn LoadValue + Sync),
    store_value: &(dyn StoreValue + Sync),
    read_variable: &Arc<ReadVariable>,
) -> std::result::Result<BlobDigest, StoreError> {
    match &expression.0 {
        Expression::Unit => {
            return Ok(store_value
                .store_value(&HashedValue::from(Arc::new(Value::empty())))
                .await?)
        }
        Expression::Literal(literal_value) => Ok(literal_value.clone()),
        Expression::Apply { callee, argument } => {
            let evaluated_callee =
                Box::pin(evaluate(callee, load_value, store_value, read_variable)).await?;
            let evaluated_argument =
                Box::pin(evaluate(argument, load_value, store_value, read_variable)).await?;
            let closure = match Closure::deserialize(&evaluated_callee, load_value).await {
                Ok(success) => success,
                Err(_) => todo!(),
            };
            call_method(
                &closure.parameter_name,
                &closure.captured_variables,
                &closure.body,
                &evaluated_argument,
                load_value,
                store_value,
                read_variable,
            )
            .await
        }
        Expression::ReadVariable(name) => Ok(read_variable(&name).await),
        Expression::Lambda {
            parameter_name,
            body,
        } => {
            let mut captured_variables = BTreeMap::new();
            for captured_name in find_captured_names(body).into_iter() {
                let captured_value = read_variable(&captured_name).await;
                captured_variables.insert(captured_name, captured_value);
            }
            let closure = Closure::new(parameter_name.clone(), body.clone(), captured_variables);
            let serialized = closure.serialize(store_value).await?;
            Ok(serialized)
        }
        Expression::Construct(arguments) => {
            let mut evaluated_arguments = Vec::new();
            for argument in arguments {
                let evaluated_argument =
                    Box::pin(evaluate(argument, load_value, store_value, read_variable)).await?;
                evaluated_arguments.push(evaluated_argument);
            }
            Ok(HashedValue::from(Arc::new(Value::new(
                ValueBlob::empty(),
                evaluated_arguments,
            )))
            .digest()
            .clone())
        }
    }
}

1	use crate::types::Name;
2	use astraea::tree::{BlobDigest, HashedValue, ReferenceIndex, Value, ValueDeserializationError};
3	use astraea::{
4	storage::{LoadValue, StoreError, StoreValue},
5	tree::ValueBlob,
6	};
7	use serde::{Deserialize, Serialize};
8	use std::fmt::Display;
9	use std::future::Future;
10	use std::hash::Hash;
11	use std::{
12	collections::{BTreeMap, BTreeSet},
13	pin::Pin,
14	sync::Arc,
15	};
16
17	pub trait PrintExpression {
18	fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result;
19	}
20
21	#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Clone, Serialize, Deserialize)]
22	pub enum Expression<E, V>
23	where
24	E: Clone + Display + PrintExpression,
25	V: Clone + Display,
26	{
27	Unit,
28	Literal(V),
29	Apply { callee: E, argument: E },
30	ReadVariable(Name),
31	Lambda { parameter_name: Name, body: E },
32	Construct(Vec<E>),
33	}
34
35	impl<E, V> PrintExpression for Expression<E, V>
36	where
37	E: Clone + Display + PrintExpression,
38	V: Clone + Display,
39	{
40	fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {	25✔
41	match self {	25✔
UNCOV 42	Expression::Unit => write!(writer, "()"),	×
43	Expression::Literal(literal_value) => {	3✔
44	write!(writer, "literal({})", literal_value)	3✔
45	}
46	Expression::Apply { callee, argument } => {	2✔
47	callee.print(writer, level)?;	2✔
48	write!(writer, "(")?;	2✔
49	argument.print(writer, level)?;	2✔
50	write!(writer, ")")	2✔
51	}
52	Expression::ReadVariable(name) => {	8✔
53	write!(writer, "{}", &name.key)	8✔
54	}
NEW 55	Expression::Lambda {	×
56	parameter_name,	11✔
57	body,	11✔
58	} => {	11✔
59	write!(writer, "({}) =>\n", parameter_name)?;	11✔
60	let indented = level + 1;	11✔
61	for _ in 0..(indented * 2) {	11✔
62	write!(writer, " ")?;	28✔
63	}
64	body.print(writer, indented)	11✔
65	}
66	Expression::Construct(arguments) => {	1✔
67	write!(writer, "construct(")?;	1✔
68	for argument in arguments {	5✔
69	argument.print(writer, level)?;	2✔
70	write!(writer, ", ")?;	2✔
71	}
72	write!(writer, ")")	1✔
73	}
74	}
75	}
76	}
77
78	impl<E, V> Expression<E, V>
79	where
80	E: Clone + Display + PrintExpression,
81	V: Clone + Display,
82	{
UNCOV 83	pub fn to_string(&self) -> String {	×
UNCOV 84	let mut result = String::new();	×
UNCOV 85	self.print(&mut result, 0).unwrap();	×
UNCOV 86	result	×
87	}
88
89	pub fn make_unit() -> Self {	2✔
90	Expression::Unit	2✔
91	}
92
93	pub fn make_literal(value: V) -> Self {	6✔
94	Expression::Literal(value)	6✔
95	}
96
97	pub fn make_apply(callee: E, argument: E) -> Self {	8✔
98	Expression::Apply { callee, argument }
99	}
100
101	pub fn make_lambda(parameter_name: Name, body: E) -> Self {	17✔
102	Expression::Lambda {
103	parameter_name,
104	body,
105	}
106	}
107
108	pub fn make_construct(arguments: Vec<E>) -> Self {	1✔
109	Expression::Construct(arguments)	1✔
110	}
111
112	pub async fn map_child_expressions<	16✔
113	't,
114	Expr: Clone + Display + PrintExpression,
115	V2: Clone + Display,
116	Error,
117	F,
118	G,
119	>(
120	&self,
121	transform_expression: &'t F,
122	transform_value: &'t G,
123	) -> Result<Expression<Expr, V2>, Error>
124	where
125	F: Fn(&E) -> Pin<Box<dyn Future<Output = Result<Expr, Error>> + 't>>,
126	G: Fn(&V) -> Pin<Box<dyn Future<Output = Result<V2, Error>> + 't>>,
127	{
128	match self {	16✔
NEW 129	Expression::Unit => Ok(Expression::Unit),	×
130	Expression::Literal(value) => Ok(Expression::Literal(transform_value(value).await?)),	10✔
NEW 131	Expression::Apply { callee, argument } => Ok(Expression::Apply {	×
NEW 132	callee: transform_expression(callee).await?,	×
NEW 133	argument: transform_expression(argument).await?,	×
134	}),
NEW 135	Expression::ReadVariable(name) => Ok(Expression::ReadVariable(name.clone())),	×
NEW 136	Expression::Lambda {	×
137	parameter_name,	3✔
138	body,	3✔
139	} => Ok(Expression::Lambda {	3✔
140	parameter_name: parameter_name.clone(),	3✔
141	body: transform_expression(body).await?,	3✔
142	}),
143	Expression::Construct(items) => {	3✔
144	let mut transformed_items = Vec::new();	3✔
145	for item in items.iter() {	9✔
146	transformed_items.push(transform_expression(item).await?);	6✔
147	}
148	Ok(Expression::Construct(transformed_items))	3✔
149	}
150	}
151	}
152	}
153
154	impl<E, V> Display for Expression<E, V>
155	where
156	E: Clone + Display + PrintExpression,
157	V: Clone + Display,
158	{
159	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	6✔
160	self.print(f, 0)	6✔
161	}
162	}
163
164	#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Clone)]
165	pub struct DeepExpression(pub Expression<Arc<DeepExpression>, BlobDigest>);
166
167	impl PrintExpression for DeepExpression {
NEW 168	fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {	×
NEW 169	self.0.print(writer, level)	×
170	}
171	}
172
173	impl PrintExpression for Arc<DeepExpression> {
174	fn print(&self, writer: &mut dyn std::fmt::Write, level: usize) -> std::fmt::Result {	17✔
175	self.0.print(writer, level)	17✔
176	}
177	}
178
179	impl Display for DeepExpression {
180	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	6✔
181	write!(f, "{}", self.0)	6✔
182	}
183	}
184
185	pub type ShallowExpression = Expression<BlobDigest, BlobDigest>;
186
187	impl PrintExpression for BlobDigest {
NEW 188	fn print(&self, writer: &mut dyn std::fmt::Write, _level: usize) -> std::fmt::Result {	×
NEW 189	write!(writer, "{}", self)	×
190	}
191	}
192
193	pub type ReferenceExpression = Expression<ReferenceIndex, ReferenceIndex>;
194
195	impl PrintExpression for ReferenceIndex {
NEW 196	fn print(&self, writer: &mut dyn std::fmt::Write, _level: usize) -> std::fmt::Result {	×
NEW 197	write!(writer, "{}", self)	×
198	}
199	}
200
201	pub fn to_reference_expression(	6✔
202	expression: &ShallowExpression,
203	) -> (ReferenceExpression, Vec<BlobDigest>) {
204	match expression {	6✔
NEW 205	Expression::Unit => (ReferenceExpression::Unit, vec![]),	×
206	Expression::Literal(value) => (	4✔
207	ReferenceExpression::Literal(ReferenceIndex(0)),	4✔
208	vec![*value],	4✔
209	),
NEW 210	Expression::Apply { callee, argument } => (	×
NEW 211	ReferenceExpression::Apply {	×
NEW 212	callee: ReferenceIndex(0),	×
NEW 213	argument: ReferenceIndex(1),	×
214	},
215	// TODO: deduplicate?
NEW 216	vec![callee, argument],	×
217	),
NEW 218	Expression::ReadVariable(name) => (ReferenceExpression::ReadVariable(name.clone()), vec![]),	×
219	Expression::Lambda {
220	parameter_name,	1✔
221	body,	1✔
222	} => (	1✔
223	ReferenceExpression::Lambda {	1✔
224	parameter_name: parameter_name.clone(),	1✔
225	body: ReferenceIndex(0),	1✔
226	},
227	vec![*body],	1✔
228	),
229	Expression::Construct(items) => (	1✔
230	ReferenceExpression::Construct(	1✔
231	(0..items.len())	1✔
232	.map(\|index\| ReferenceIndex(index as u64))	4✔
233	.collect(),	1✔
234	),
235	// TODO: deduplicate?
236	items.clone(),	1✔
237	),
238	}
239	}
240
241	pub async fn deserialize_shallow(value: &Value) -> Result<ShallowExpression, ()> {	10✔
242	let reference_expression: ReferenceExpression = postcard::from_bytes(value.blob().as_slice())	5✔
243	.unwrap(/TODO/);
244	reference_expression	5✔
245	.map_child_expressions(
246	&\|child: &ReferenceIndex\| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {	8✔
247	let child = value.references()[child.0 as usize].clone();	3✔
248	Box::pin(async move { Ok(child) })	9✔
249	},
250	&\|child: &ReferenceIndex\| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {	8✔
251	let child = value.references()[child.0 as usize].clone();	3✔
252	Box::pin(async move { Ok(child) })	9✔
253	},
254	)
255	.await	5✔
256	}
257
258	pub async fn deserialize_recursively(	5✔
259	root: &BlobDigest,
260	load_value: &(dyn LoadValue + Sync),
261	) -> Result<DeepExpression, ()> {
262	let root_loaded = load_value.load_value(root).await.unwrap(/TODO/).hash().unwrap(/TODO/);	15✔
263	let shallow = deserialize_shallow(&root_loaded.value()).await?;	10✔
264	let deep = shallow	5✔
265	.map_child_expressions(
266	&\|child: &BlobDigest\| -> Pin<Box<dyn Future<Output = Result<Arc<DeepExpression>, ()>>>> {	3✔
267	let child = child.clone();	3✔
268	Box::pin(async move { deserialize_recursively(&child, load_value)	6✔
269	.await	3✔
270	.map(\|success\| Arc::new(success)) })	9✔
271	},
272	&\|child: &BlobDigest\| -> Pin<Box<dyn Future<Output = Result<BlobDigest, ()>>>> {	3✔
273	let child = child.clone();	3✔
274	Box::pin(async move { Ok(child) })	9✔
275	},
276	)
NEW 277	.await?;	×
278	Ok(DeepExpression(deep))
279	}
280
281	pub fn expression_to_value(expression: &ShallowExpression) -> Value {	6✔
282	let (reference_expression, references) = to_reference_expression(expression);	6✔
283	let blob = postcard::to_allocvec(&reference_expression).unwrap(/TODO/);	6✔
284	Value::new(
285	ValueBlob::try_from(bytes::Bytes::from_owner(blob)).unwrap(/TODO/),	6✔
286	references,	6✔
287	)
288	}
289
290	pub async fn serialize_shallow(	6✔
291	expression: &ShallowExpression,
292	storage: &(dyn StoreValue + Sync),
293	) -> std::result::Result<BlobDigest, StoreError> {
294	let value = expression_to_value(expression);	6✔
295	storage	6✔
296	.store_value(&HashedValue::from(Arc::new(value)))	6✔
297	.await	6✔
298	}
299
300	pub async fn serialize_recursively(	6✔
301	expression: &DeepExpression,
302	storage: &(dyn StoreValue + Sync),
303	) -> std::result::Result<BlobDigest, StoreError> {
304	let shallow_expression: ShallowExpression = expression	12✔
305	.0	6✔
306	.map_child_expressions(&\|child: &Arc<DeepExpression>\| -> Pin<	6✔
307	Box<dyn Future<Output = Result<BlobDigest, StoreError>>>,
308	> {	3✔
309	let child = child.clone();	3✔
310	Box::pin(async move {	6✔
311	serialize_recursively(&child, storage)	3✔
312	.await	3✔
313	})
314	},&\|child: &BlobDigest\| -> Pin<	9✔
315	Box<dyn Future<Output = Result<BlobDigest, StoreError>>>,
316	> {	4✔
317	let child = child.clone();	4✔
318	Box::pin(async move {	8✔
319	Ok(child)	4✔
320	})
321	})
322	.await?;	6✔
323	serialize_shallow(&shallow_expression, storage).await
324	}
325
326	#[derive(Debug)]
327	pub struct Closure {
328	parameter_name: Name,
329	body: Arc<DeepExpression>,
330	captured_variables: BTreeMap<Name, BlobDigest>,
331	}
332
333	#[derive(Debug, Serialize, Deserialize)]
334	pub struct ClosureBlob {
335	parameter_name: Name,
336	captured_variables: BTreeMap<Name, ReferenceIndex>,
337	}
338
339	impl ClosureBlob {
340	pub fn new(parameter_name: Name, captured_variables: BTreeMap<Name, ReferenceIndex>) -> Self {	3✔
341	Self {
342	parameter_name,
343	captured_variables,
344	}
345	}
346	}
347
348	impl Closure {
349	pub fn new(	5✔
350	parameter_name: Name,
351	body: Arc<DeepExpression>,
352	captured_variables: BTreeMap<Name, BlobDigest>,
353	) -> Self {
354	Self {
355	parameter_name,
356	body,
357	captured_variables,
358	}
359	}
360
361	pub async fn serialize(	3✔
362	&self,
363	store_value: &(dyn StoreValue + Sync),
364	) -> Result<BlobDigest, StoreError> {
365	let mut references = vec![serialize_recursively(&self.body, store_value).await?];	6✔
366	let mut captured_variables = BTreeMap::new();
NEW 367	for (name, reference) in self.captured_variables.iter() {	×
368	let index = ReferenceIndex(references.len() as u64);
369	captured_variables.insert(name.clone(), index);
370	references.push(reference.clone());
371	}
372	let closure_blob = ClosureBlob::new(self.parameter_name.clone(), captured_variables);
373	let closure_blob_bytes = postcard::to_allocvec(&closure_blob).unwrap(/TODO/);
374	store_value
375	.store_value(&HashedValue::from(Arc::new(Value::new(
376	ValueBlob::try_from(bytes::Bytes::from_owner(closure_blob_bytes)).unwrap(/TODO/),
377	references,
378	))))
379	.await
380	}
381
382	pub async fn deserialize(	2✔
383	root: &BlobDigest,
384	load_value: &(dyn LoadValue + Sync),
385	) -> Result<Closure, ValueDeserializationError> {
386	let loaded_root = match load_value.load_value(root).await {	4✔
387	Some(success) => success,	2✔
NEW 388	None => return Err(ValueDeserializationError::BlobUnavailable(root.clone())),	×
389	};
390	let root_value = loaded_root.hash().unwrap(/TODO/).value().clone();	2✔
391	let closure_blob: ClosureBlob = match postcard::from_bytes(&root_value.blob().as_slice()) {	4✔
392	Ok(success) => success,
NEW 393	Err(error) => return Err(ValueDeserializationError::Postcard(error)),	×
394	};
395	let body_reference = &root_value.references()[0];
396	let body = deserialize_recursively(body_reference, load_value).await.unwrap(/TODO/);	4✔
397	let mut captured_variables = BTreeMap::new();	2✔
398	for (name, index) in closure_blob.captured_variables {	2✔
399	let reference = &root_value.references()[index.0 as usize];
400	captured_variables.insert(name, reference.clone());
401	}
402	Ok(Closure::new(	2✔
403	closure_blob.parameter_name,	2✔
404	Arc::new(body),	2✔
405	captured_variables,	2✔
406	))
407	}
408	}
409
410	async fn call_method(	2✔
411	parameter_name: &Name,
412	captured_variables: &BTreeMap<Name, BlobDigest>,
413	body: &DeepExpression,
414	argument: &BlobDigest,
415	load_value: &(dyn LoadValue + Sync),
416	store_value: &(dyn StoreValue + Sync),
417	read_variable: &Arc<ReadVariable>,
418	) -> std::result::Result<BlobDigest, StoreError> {
419	let read_variable_in_body: Arc<ReadVariable> = Arc::new({	2✔
420	let parameter_name = parameter_name.clone();	2✔
421	let argument = argument.clone();	2✔
422	let captured_variables = captured_variables.clone();	2✔
423	let read_variable = read_variable.clone();	2✔
424	move \|name: &Name\| -> Pin<Box<dyn core::future::Future<Output = BlobDigest> + Send>> {	2✔
NEW 425	if name == &parameter_name {	×
NEW 426	let argument = argument.clone();	×
NEW 427	Box::pin(core::future::ready(argument))	×
NEW 428	} else if let Some(found) = captured_variables.get(name) {	×
429	Box::pin(core::future::ready(found.clone()))
430	} else {
NEW 431	read_variable(name)	×
432	}
433	}
434	});
435	Box::pin(evaluate(	2✔
436	&body,	2✔
437	load_value,	2✔
438	store_value,	2✔
439	&read_variable_in_body,	2✔
440	))
441	.await	2✔
442	}
443
444	#[derive(Debug, Clone)]
445	pub struct InMemoryValue {
446	pub blob: ValueBlob,
447	pub references: Vec<Pointer>,
448	}
449
450	impl InMemoryValue {
NEW 451	pub fn new(blob: ValueBlob, references: Vec<Pointer>) -> Self {	×
452	Self { blob, references }
453	}
454	}
455
456	#[derive(Debug, Clone)]
457	pub enum Pointer {
458	Value(HashedValue),
459	Reference(BlobDigest),
460	InMemoryValue(InMemoryValue),
461	}
462
463	impl Pointer {
NEW 464	pub fn serialize(self) -> HashedValue {	×
UNCOV 465	match self {	×
NEW 466	Pointer::Value(hashed_value) => hashed_value,	×
467	Pointer::Reference(_blob_digest) => todo!(),
NEW 468	Pointer::InMemoryValue(_in_memory_value) => {	×
469	todo!()
470	}
471	}
472	}
473
UNCOV 474	pub async fn serialize_to_flat_value(&self) -> Option<Arc<Value>> {	×
UNCOV 475	match self {	×
UNCOV 476	Pointer::Value(hashed_value) => {	×
UNCOV 477	if hashed_value.value().references().is_empty() {	×
UNCOV 478	Some(hashed_value.value().clone())	×
479	} else {
480	None	×
481	}
482	}
483	Pointer::Reference(_blob_digest) => todo!(),
NEW 484	Pointer::InMemoryValue(_in_memory_value) => {	×
485	todo!()
486	}
487	}
488	}
489	}
490
491	pub type ReadVariable =
492	dyn Fn(&Name) -> Pin<Box<dyn core::future::Future<Output = BlobDigest> + Send>> + Send + Sync;
493
494	fn find_captured_names(expression: &DeepExpression) -> BTreeSet<Name> {	6✔
495	match &expression.0 {	6✔
NEW 496	Expression::Unit => BTreeSet::new(),	×
497	Expression::Literal(_blob_digest) => BTreeSet::new(),	4✔
NEW 498	Expression::Apply { callee, argument } => {	×
NEW 499	let mut result = find_captured_names(callee);	×
NEW 500	result.append(&mut find_captured_names(argument));	×
NEW 501	result	×
502	}
NEW 503	Expression::ReadVariable(name) => BTreeSet::from([name.clone()]),	×
504	Expression::Lambda {
505	parameter_name,	1✔
506	body,	1✔
507	} => {	1✔
508	let mut result = find_captured_names(body);	1✔
509	result.remove(&parameter_name);	1✔
510	result	1✔
511	}
512	Expression::Construct(arguments) => {	1✔
513	let mut result = BTreeSet::new();	1✔
514	for argument in arguments {	5✔
515	result.append(&mut find_captured_names(argument));
516	}
517	result	1✔
518	}
519	}
520	}
521
522	pub async fn evaluate(	12✔
523	expression: &DeepExpression,
524	load_value: &(dyn LoadValue + Sync),
525	store_value: &(dyn StoreValue + Sync),
526	read_variable: &Arc<ReadVariable>,
527	) -> std::result::Result<BlobDigest, StoreError> {
528	match &expression.0 {	12✔
529	Expression::Unit => {
530	return Ok(store_value	2✔
531	.store_value(&HashedValue::from(Arc::new(Value::empty())))	2✔
532	.await?)	2✔
533	}
534	Expression::Literal(literal_value) => Ok(literal_value.clone()),	4✔
535	Expression::Apply { callee, argument } => {	2✔
536	let evaluated_callee =	2✔
537	Box::pin(evaluate(callee, load_value, store_value, read_variable)).await?;	2✔
538	let evaluated_argument =	2✔
NEW 539	Box::pin(evaluate(argument, load_value, store_value, read_variable)).await?;	×
540	let closure = match Closure::deserialize(&evaluated_callee, load_value).await {	2✔
541	Ok(success) => success,	2✔
542	Err(_) => todo!(),
543	};
544	call_method(
545	&closure.parameter_name,	2✔
546	&closure.captured_variables,	2✔
547	&closure.body,	2✔
548	&evaluated_argument,	2✔
549	load_value,	2✔
550	store_value,	2✔
551	read_variable,	2✔
552	)
553	.await	2✔
554	}
NEW 555	Expression::ReadVariable(name) => Ok(read_variable(&name).await),	×
556	Expression::Lambda {
557	parameter_name,	3✔
558	body,	3✔
559	} => {	3✔
560	let mut captured_variables = BTreeMap::new();	3✔
561	for captured_name in find_captured_names(body).into_iter() {	3✔
562	let captured_value = read_variable(&captured_name).await;	×
563	captured_variables.insert(captured_name, captured_value);
564	}
565	let closure = Closure::new(parameter_name.clone(), body.clone(), captured_variables);	3✔
566	let serialized = closure.serialize(store_value).await?;	3✔
567	Ok(serialized)
568	}
569	Expression::Construct(arguments) => {	1✔
570	let mut evaluated_arguments = Vec::new();	1✔
571	for argument in arguments {	5✔
572	let evaluated_argument =	2✔
573	Box::pin(evaluate(argument, load_value, store_value, read_variable)).await?;	2✔
574	evaluated_arguments.push(evaluated_argument);
575	}
576	Ok(HashedValue::from(Arc::new(Value::new(	1✔
577	ValueBlob::empty(),	1✔
578	evaluated_arguments,	1✔
579	)))
580	.digest()	1✔
581	.clone())	1✔
582	}
583	}
584	}

TyRoXx / NonlocalityOS / 14775473202

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous