tweag/nickel
1
1
Fork 0
mirror of https://github.com/tweag/nickel.git synced 2024-11-10 10:46:49 +03:00
Code Issues Projects Releases Wiki Activity

Remove dead code of previous metavalues representation

Browse Source
This commit is contained in:
Yann Hamdaoui 2020-12-02 13:15:32 +01:00
parent f55679a579
commit 305fd7259d
6 changed files with 31 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
src/eval.rs
View File

@ -429,51 +429,6 @@ where
return Err(EvalError::Other(String::from("empty metavalue"), pos));
}
}
Term::Contract(_, _) if enriched_strict => {
return Err(EvalError::Other(
String::from(
"Expected a simple term, got a Contract. Contracts cannot be evaluated",
),
pos,
));
}
enriched @ Term::DefaultValue(_) | enriched @ Term::Docstring(_, _)
if enriched_strict =>
{
/* Since we are forcing an enriched value, we are morally breaking subject
* reduction (i.e., the type of the current term changes from `enriched something`
* to just `something`). Updating a thunk after having performed this forcing may
* alter the semantics of the program in an unexpected way (see issue
* https://github.com/tweag/nickel/issues/123): we update potential thunks now so
* that their content remains an enriched value.
*/
let update_closure = Closure {
body: RichTerm {
term: Box::new(enriched),
pos,
},
env,
};
update_thunks(&mut stack, &update_closure);
let Closure {
body:
RichTerm {
term: enriched_box,
pos: _,
},
env,
} = update_closure;
let t = match *enriched_box {
Term::DefaultValue(t) | Term::Docstring(_, t) => t,
_ => panic!("eval::eval(): previous match enforced that a term is a default or a docstring, but matched something else")
};
Closure { body: t, env }
}
Term::ContractWithDefault(ty, label, t) if enriched_strict => Closure {
body: Term::Assume(ty, label, t).into(),
env,
},
Term::ResolvedImport(id) => {
if let Some(t) = resolver.get(id) {
Closure::atomic_closure(t)
@ -685,35 +640,6 @@ fn subst(rt: RichTerm, global_env: &Environment, env: &Environment) -> RichTerm
RichTerm::new(Term::StrChunks(chunks), pos)
}
Term::Contract(ty, label) => {
let ty = match ty {
Types(AbsType::Flat(t)) => {
Types(AbsType::Flat(subst_(t, global_env, env, bound)))
}
ty => ty,
};
RichTerm::new(Term::Contract(ty, label), pos)
}
Term::DefaultValue(t) => {
let t = subst_(t, global_env, env, bound);
RichTerm::new(Term::DefaultValue(t), pos)
}
Term::ContractWithDefault(ty, lbl, t) => {
let ty = match ty {
Types(AbsType::Flat(t)) => Types(AbsType::Flat(subst_(
t,
global_env,
env,
Cow::Borrowed(bound.as_ref()),
))),
ty => ty,
};
let t = subst_(t, global_env, env, bound);
RichTerm::new(Term::ContractWithDefault(ty, lbl, t), pos)
}
Term::MetaValue(meta) => {
let contract = meta.contract.map(|(ty, lbl)| {
let ty = match ty {
@ -740,11 +666,6 @@ fn subst(rt: RichTerm, global_env: &Environment, env: &Environment) -> RichTerm
RichTerm::new(Term::MetaValue(meta), pos)
}
Term::Docstring(s, t) => {
let t = subst_(t, global_env, env, bound);
RichTerm::new(Term::Docstring(s, t), pos)
}
}
}
@ -863,12 +784,26 @@ mod tests {
assert_eq!(Ok(Term::Bool(true)), eval_no_import(lambda));
}
fn mk_default(t: RichTerm) -> Term {
use crate::term::MergePriority;
let mut meta = MetaValue::from(t);
meta.priority = MergePriority::Default;
Term::MetaValue(meta)
}
fn mk_docstring<S>(t: RichTerm, s: S) -> Term
where
S: Into<String>,
{
let mut meta = MetaValue::from(t);
meta.doc.replace(s.into());
Term::MetaValue(meta)
}
#[test]
fn enriched_terms_unwrapping() {
let t = Term::DefaultValue(
Term::DefaultValue(Term::Docstring("a".to_string(), Term::Bool(false).into()).into())
.into(),
)
let t = mk_default(mk_default(mk_docstring(Term::Bool(false).into(), "a").into()).into())
.into();
assert_eq!(Ok(Term::Bool(false)), eval_no_import(t));
}
@ -878,7 +813,7 @@ mod tests {
let t = mk_term::op2(
BinaryOp::Merge(),
Term::Num(1.0),
Term::DefaultValue(Term::Num(2.0).into()),
mk_default(Term::Num(2.0).into()),
);
assert_eq!(Ok(Term::Num(1.0)), eval_no_import(t));
}
@ -887,8 +822,8 @@ mod tests {
fn merge_incompatible_defaults() {
let t = mk_term::op2(
BinaryOp::Merge(),
Term::DefaultValue(Term::Num(1.0).into()),
Term::DefaultValue(Term::Num(2.0).into()),
mk_default(Term::Num(1.0).into()),
mk_default(Term::Num(2.0).into()),
);
eval_no_import(t).unwrap_err();

132
src/merge.rs
View File

@ -246,138 +246,6 @@ pub fn merge(
env,
})
}
// Right-biased: when merging two docstrings (s1,t2) and (s2,t2), the right one will end up
// as the outermost position in the resulting term (s2,(s1,merge t1 t2))
(t1, Term::Docstring(s, t2)) => {
let Closure { body, env } = mk_merge_closure(
RichTerm {
term: Box::new(t1),
pos: pos1,
},
env1,
t2,
env2,
);
let body = Term::Docstring(s, body).into();
Ok(Closure { body, env })
}
(Term::Docstring(s, t1), t2) => {
let Closure { body, env } = mk_merge_closure(
t1,
env1,
RichTerm {
term: Box::new(t2),
pos: pos2,
},
env2,
);
let body = Term::Docstring(s, body).into();
Ok(Closure { body, env })
}
// Default merging
(Term::DefaultValue(t1), Term::DefaultValue(t2)) => {
let Closure { body, env } = mk_merge_closure(t1, env1, t2, env2);
let body = Term::DefaultValue(body).into();
Ok(Closure { body, env })
}
(Term::DefaultValue(t1), Term::ContractWithDefault(ty, lbl, t2))
| (Term::ContractWithDefault(ty, lbl, t2), Term::DefaultValue(t1)) => {
let Closure { body, mut env } = mk_merge_closure(t1, env1, t2, env2.clone());
let ty_closure = ty.closurize(&mut env, env2);
let body = Term::ContractWithDefault(ty_closure, lbl, body).into();
Ok(Closure { body, env })
}
// Composed contracts carry and blame their original label. As any contract, the composite
// still requires a label, but it will be ignored, so we can provide a dummy one.
(Term::ContractWithDefault(ty1, lbl1, t1), Term::ContractWithDefault(ty2, lbl2, t2)) => {
let Closure { body, mut env } = mk_merge_closure(t1, env1.clone(), t2, env2.clone());
let body = Term::ContractWithDefault(
merge_types_closure(&mut env, ty1, lbl1, env1, ty2, lbl2, env2),
Label::dummy(),
body,
)
.into();
Ok(Closure { body, env })
}
// We need to keep the environment of contracts as well: custom contracts may use variables
// from the environment, and even standard contracts need access to builtins contracts (see
// issue https://github.com/tweag/nickel/issues/117)
(Term::DefaultValue(t), Term::Contract(ty, lbl)) => {
let mut env = HashMap::new();
let t_closure = t.closurize(&mut env, env1);
let ty_closure = ty.closurize(&mut env, env2);
let body = Term::ContractWithDefault(ty_closure, lbl, t_closure).into();
Ok(Closure { body, env })
}
(Term::Contract(ty, lbl), Term::DefaultValue(t)) => {
let mut env = HashMap::new();
let ty_closure = ty.closurize(&mut env, env1);
let t_closure = t.closurize(&mut env, env2);
let body = Term::ContractWithDefault(ty_closure, lbl, t_closure).into();
Ok(Closure { body, env })
}
(Term::DefaultValue(_), t) => {
let body = RichTerm {
term: Box::new(t),
pos: pos2,
};
Ok(Closure { body, env: env2 })
}
(t, Term::DefaultValue(_)) => {
let body = RichTerm {
term: Box::new(t),
pos: pos1,
};
Ok(Closure { body, env: env1 })
}
// Contracts merging
(Term::Contract(ty1, lbl1), Term::Contract(ty2, lbl2)) => {
let mut env = HashMap::new();
let body = Term::Contract(
merge_types_closure(&mut env, ty1, lbl1, env1, ty2, lbl2, env2),
Label::dummy(),
)
.into();
Ok(Closure { body, env })
}
(Term::Contract(ty1, lbl1), Term::ContractWithDefault(ty2, lbl2, t)) => {
let mut env = HashMap::new();
let ty_closure =
merge_types_closure(&mut env, ty1, lbl1, env1, ty2, lbl2, env2.clone());
let t_closure = t.closurize(&mut env, env2);
let body = Term::ContractWithDefault(ty_closure, Label::dummy(), t_closure).into();
Ok(Closure { body, env })
}
(Term::ContractWithDefault(ty1, lbl1, t), Term::Contract(ty2, lbl2)) => {
let mut env = HashMap::new();
let ty_closure =
merge_types_closure(&mut env, ty1, lbl1, env1.clone(), ty2, lbl2, env2);
let t_closure = t.closurize(&mut env, env1);
let body = Term::ContractWithDefault(ty_closure, Label::dummy(), t_closure).into();
Ok(Closure { body, env })
}
(Term::Contract(ty, lbl), t) | (Term::ContractWithDefault(ty, lbl, _), t) => {
let mut env = HashMap::new();
let t = RichTerm {
term: Box::new(t),
pos: pos2,
};
let ty_closure = ty.closurize(&mut env, env1);
let t_closure = t.closurize(&mut env, env2);
let body = Term::Assume(ty_closure, lbl, t_closure).into();
Ok(Closure { body, env })
}
(t, Term::Contract(ty, lbl)) | (t, Term::ContractWithDefault(ty, lbl, _)) => {
let mut env = HashMap::new();
let t = RichTerm {
term: Box::new(t),
pos: pos1,
};
let t_closure = t.closurize(&mut env, env1);
let ty_closure = ty.closurize(&mut env, env2);
let body = Term::Assume(ty_closure, lbl, t_closure).into();
Ok(Closure { body, env })
}
// Merge put together the fields of records, and recursively merge
// fields that are present in both terms
(Term::Record(m1), Term::Record(m2)) => {

5
src/serialize.rs
View File

@ -72,6 +72,7 @@ impl Serialize for RichTerm {
/// Check that a term is serializable. Serializable terms are booleans, numbers, strings, enum,
/// lists of serializable terms or records of serializable terms.
pub fn validate(t: &RichTerm) -> Result<(), SerializationError> {
use crate::term;
use Term::*;
match t.term.as_ref() {
@ -84,7 +85,9 @@ pub fn validate(t: &RichTerm) -> Result<(), SerializationError> {
vec.iter().try_for_each(validate)?;
Ok(())
}
DefaultValue(ref t) | ContractWithDefault(_, _, ref t) | Docstring(_, ref t) => validate(t),
MetaValue(term::MetaValue {
value: Some(ref t), ..
}) => validate(t),
_ => Err(SerializationError::NonSerializable(t.clone())),
}
}

116
src/term.rs
View File

@ -126,36 +126,9 @@ pub enum Term {
#[serde(skip)]
Wrapped(i32, RichTerm),
/// A contract. Enriched value.
///
/// A contract at the term level. This contract is enforced when merged with a value.
#[serde(skip)]
Contract(Types, Label),
/// A default value. Enriched value.
///
/// An enriched term representing a default value. It is dropped as soon as it is merged with a
/// concrete value. Otherwise, if it lives long enough to be accessed, it evaluates to the
/// underlying term.
#[serde(skip_deserializing)]
DefaultValue(RichTerm),
/// A contract with combined with default value. Enriched value.
///
/// This is a combination generated during evaluation, when merging a contract and a default
/// value, as both need to be remembered.
#[serde(serialize_with = "crate::serialize::serialize_contract_default")]
#[serde(skip_deserializing)]
ContractWithDefault(Types, Label, RichTerm),
#[serde(serialize_with = "crate::serialize::serialize_meta_value")]
MetaValue(MetaValue),
/// A term together with its documentation string. Enriched value.
#[serde(serialize_with = "crate::serialize::serialize_docstring")]
#[serde(skip_deserializing)]
Docstring(String, RichTerm),
/// An unresolved import.
#[serde(skip)]
Import(String),
@ -250,24 +223,13 @@ impl Term {
func(t1);
func(t2)
}
Bool(_)
| Num(_)
| Str(_)
| Lbl(_)
| Var(_)
| Sym(_)
| Enum(_)
| Contract(_, _)
| Import(_)
Bool(_) | Num(_) | Str(_) | Lbl(_) | Var(_) | Sym(_) | Enum(_) | Import(_)
| ResolvedImport(_) => {}
Fun(_, ref mut t)
| Op1(_, ref mut t)
| Promise(_, _, ref mut t)
| Assume(_, _, ref mut t)
| Wrapped(_, ref mut t)
| DefaultValue(ref mut t)
| Docstring(_, ref mut t)
| ContractWithDefault(_, _, ref mut t) => {
| Wrapped(_, ref mut t) => {
func(t);
}
MetaValue(ref mut meta) => {
@ -313,11 +275,7 @@ impl Term {
Term::List(_) => Some("List"),
Term::Sym(_) => Some("Sym"),
Term::Wrapped(_, _) => Some("Wrapped"),
Term::Contract(_, _)
| Term::ContractWithDefault(_, _, _)
| Term::Docstring(_, _)
| Term::DefaultValue(_)
| Term::MetaValue(_) => Some("Metavalue"),
Term::MetaValue(_) => Some("Metavalue"),
Term::Let(_, _, _)
| Term::App(_, _)
| Term::Var(_)
@ -358,13 +316,6 @@ impl Term {
Term::List(_) => String::from("[ ... ]"),
Term::Sym(_) => String::from("<sym>"),
Term::Wrapped(_, _) => String::from("<wrapped>"),
Term::Contract(_, _) => String::from("<enriched:contract>"),
Term::ContractWithDefault(_, _, ref t) => {
format!("<enriched:contract,default={}>", (*t.term).shallow_repr())
}
Term::Docstring(_, ref t) => {
format!("<enriched:doc,term={}>", (*t.term).shallow_repr())
}
Term::MetaValue(ref meta) => {
let mut content = String::new();
@ -388,7 +339,6 @@ impl Term {
format!("<{}{}={}>", content, value_label, value)
}
Term::DefaultValue(ref t) => format!("<enriched:default={}", (*t.term).shallow_repr()),
Term::Var(Ident(id)) => id.clone(),
Term::Let(_, _, _)
| Term::App(_, _)
@ -421,11 +371,7 @@ impl Term {
| Term::Promise(_, _, _)
| Term::Assume(_, _, _)
| Term::Wrapped(_, _)
| Term::Contract(_, _)
| Term::DefaultValue(_)
| Term::ContractWithDefault(_, _, _)
| Term::MetaValue(_)
| Term::Docstring(_, _)
| Term::Import(_)
| Term::ResolvedImport(_)
| Term::StrChunks(_)
@ -436,11 +382,7 @@ impl Term {
/// Determine if a term is an enriched value.
pub fn is_enriched(&self) -> bool {
match self {
Term::Contract(_, _)
| Term::DefaultValue(_)
| Term::ContractWithDefault(_, _, _)
| Term::Docstring(_, _)
| Term::MetaValue(_) => true,
Term::MetaValue(_) => true,
Term::Bool(_)
| Term::Num(_)
| Term::Str(_)
@ -488,11 +430,7 @@ impl Term {
| Term::Promise(_, _, _)
| Term::Assume(_, _, _)
| Term::Wrapped(_, _)
| Term::Contract(_, _)
| Term::DefaultValue(_)
| Term::ContractWithDefault(_, _, _)
| Term::MetaValue(_)
| Term::Docstring(_, _)
| Term::Import(_)
| Term::ResolvedImport(_)
| Term::StrChunks(_)
@ -1013,52 +951,6 @@ impl RichTerm {
state,
)
}
Term::Contract(ty, label) => {
let ty = match ty {
Types(AbsType::Flat(t)) => Types(AbsType::Flat(t.traverse(f, state)?)),
ty => ty,
};
Ok(RichTerm {
term: Box::new(Term::Contract(ty, label)),
pos,
})
}
Term::DefaultValue(t) => {
let t = t.traverse(f, state)?;
f(
RichTerm {
term: Box::new(Term::DefaultValue(t)),
pos,
},
state,
)
}
Term::ContractWithDefault(ty, lbl, t) => {
let ty = match ty {
Types(AbsType::Flat(t)) => Types(AbsType::Flat(t.traverse(f, state)?)),
ty => ty,
};
let t = t.traverse(f, state)?;
f(
RichTerm {
term: Box::new(Term::ContractWithDefault(ty, lbl, t)),
pos,
},
state,
)
}
Term::Docstring(s, t) => {
let t = t.traverse(f, state)?;
f(
RichTerm {
term: Box::new(Term::Docstring(s, t)),
pos,
},
state,
)
}
Term::MetaValue(meta) => {
let contract = meta
.contract

49
src/transformations.rs
View File

@ -132,55 +132,6 @@ pub mod share_normal_form {
RichTerm::new(Term::MetaValue(meta), pos)
}
}
Term::DefaultValue(t) => {
if should_share(&t.term) {
let fresh_var = fresh_var();
let inner = RichTerm {
term: Box::new(Term::DefaultValue(Term::Var(fresh_var.clone()).into())),
pos,
};
Term::Let(fresh_var, t, inner).into()
} else {
RichTerm {
term: Box::new(Term::DefaultValue(t)),
pos,
}
}
}
Term::ContractWithDefault(ty, lbl, t) => {
if should_share(&t.term) {
let fresh_var = fresh_var();
let inner = RichTerm {
term: Box::new(Term::ContractWithDefault(
ty,
lbl,
Term::Var(fresh_var.clone()).into(),
)),
pos,
};
Term::Let(fresh_var, t, inner).into()
} else {
RichTerm {
term: Box::new(Term::ContractWithDefault(ty, lbl, t)),
pos,
}
}
}
Term::Docstring(s, t) => {
if should_share(&t.term) {
let fresh_var = fresh_var();
let inner = RichTerm {
term: Box::new(Term::Docstring(s, Term::Var(fresh_var.clone()).into())),
pos,
};
Term::Let(fresh_var, t, inner).into()
} else {
RichTerm {
term: Box::new(Term::Docstring(s, t)),
pos,
}
}
}
t => RichTerm {
term: Box::new(t),
pos,

5
src/typecheck.rs
View File

@ -613,9 +613,6 @@ fn type_check_(
Term::Sym(_) => unify(state, strict, ty, mk_typewrapper::sym())
.map_err(|err| err.to_typecheck_err(state, &rt.pos)),
Term::Wrapped(_, t)
| Term::DefaultValue(t)
| Term::ContractWithDefault(_, _, t)
| Term::Docstring(_, t)
| Term::MetaValue(MetaValue {
contract: None,
value: Some(t),
@ -632,7 +629,7 @@ fn type_check_(
let new_ty = TypeWrapper::Ptr(new_var(state.table));
type_check_(state, envs, false, t, new_ty)
}
Term::Contract(_, _) | Term::MetaValue(_) => Ok(()),
Term::MetaValue(_) => Ok(()),
Term::Import(_) => unify(state, strict, ty, mk_typewrapper::dynamic())
.map_err(|err| err.to_typecheck_err(state, &rt.pos)),
Term::ResolvedImport(file_id) => {