From b79a9b81a803794a7a86d953ced24f0d3e2fd212 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Thu, 30 Jan 2020 20:23:06 +0000 Subject: Only the Form must be in a RefCell --- dhall/src/semantics/nze/value.rs | 128 ++++++++++++++++++++------------------- 1 file changed, 67 insertions(+), 61 deletions(-) (limited to 'dhall/src/semantics/nze') diff --git a/dhall/src/semantics/nze/value.rs b/dhall/src/semantics/nze/value.rs index ff0ca42..d737a0f 100644 --- a/dhall/src/semantics/nze/value.rs +++ b/dhall/src/semantics/nze/value.rs @@ -1,4 +1,4 @@ -use std::cell::{Ref, RefCell, RefMut}; +use std::cell::{Ref, RefCell}; use std::collections::HashMap; use std::rc::Rc; @@ -21,11 +21,11 @@ use crate::{Normalized, NormalizedExpr, ToExprOptions}; /// (renaming of bound variables) and beta-equivalence (normalization). It will recursively /// normalize as needed. #[derive(Clone)] -pub(crate) struct Value(Rc>); +pub(crate) struct Value(Rc); #[derive(Debug)] struct ValueInternal { - form: Form, + form: RefCell
, /// This is None if and only if `form` is `Sort` (which doesn't have a type) ty: Option, span: Span, @@ -117,28 +117,23 @@ pub(crate) enum ValueKind { impl Value { fn new(form: Form, ty: Value, span: Span) -> Value { - ValueInternal { - form, - ty: Some(ty), - span, - } - .into_value() + ValueInternal::new(form, Some(ty), span).into_value() } pub(crate) fn const_sort() -> Value { - ValueInternal { - form: Form::WHNF(ValueKind::Const(Const::Sort)), - ty: None, - span: Span::Artificial, - } + ValueInternal::new( + Form::WHNF(ValueKind::Const(Const::Sort)), + None, + Span::Artificial, + ) .into_value() } /// Construct a Value from a completely unnormalized expression. pub(crate) fn new_thunk(env: &NzEnv, tye: TyExpr) -> Value { - ValueInternal { - form: Form::Thunk(Thunk::new(env, tye.clone())), - ty: tye.get_type().ok(), - span: tye.span().clone(), - } + ValueInternal::new( + Form::Thunk(Thunk::new(env, tye.clone())), + tye.get_type().ok(), + tye.span().clone(), + ) .into_value() } /// Construct a Value from a partially normalized expression that's not in WHNF. @@ -181,21 +176,18 @@ impl Value { } } pub(crate) fn span(&self) -> Span { - self.as_internal().span.clone() + self.0.span.clone() } - fn as_internal(&self) -> Ref { - self.0.borrow() - } - fn as_internal_mut(&self) -> RefMut { - self.0.borrow_mut() + fn as_form(&self) -> Ref { + self.0.form.borrow() } /// This is what you want if you want to pattern-match on the value. /// WARNING: drop this ref before normalizing the same value or you will run into BorrowMut /// panics. pub(crate) fn kind(&self) -> Ref { self.normalize_whnf(); - Ref::map(self.as_internal(), |vint| match &vint.form { + Ref::map(self.as_form(), |form| match form { Form::Thunk(..) | Form::PartialExpr(..) => unreachable!(), Form::WHNF(k) => k, }) @@ -219,33 +211,25 @@ impl Value { } /// Mutates the contents. If no one else shares this, this avoids a RefCell lock. - fn mutate_internal(&mut self, f: impl FnOnce(&mut ValueInternal)) { + fn mutate_form(&mut self, f: impl FnOnce(&mut Form, &Option)) { match Rc::get_mut(&mut self.0) { // Mutate directly if sole owner - Some(refcell) => f(RefCell::get_mut(refcell)), + Some(vint) => f(RefCell::get_mut(&mut vint.form), &vint.ty), // Otherwise mutate through the refcell - None => f(&mut self.as_internal_mut()), + None => f(&mut self.0.form.borrow_mut(), &self.0.ty), } } /// Normalizes contents to normal form; faster than `normalize_nf` if /// no one else shares this. pub(crate) fn normalize_mut(&mut self) { - self.mutate_internal(|vint| vint.normalize_nf()) + self.mutate_form(|form, ty| form.normalize_nf(ty)) } pub(crate) fn normalize_whnf(&self) { - let borrow = self.as_internal(); - match borrow.form { - Form::Thunk(..) | Form::PartialExpr(_) => { - drop(borrow); - self.as_internal_mut().normalize_whnf(); - } - // Already in WHNF - Form::WHNF(_) => {} - } + self.0.normalize_whnf() } pub(crate) fn normalize_nf(&self) { - self.as_internal_mut().normalize_nf(); + self.0.normalize_nf() } pub(crate) fn app(&self, v: Value) -> Value { @@ -270,7 +254,7 @@ impl Value { // ); } pub(crate) fn get_type(&self) -> Result { - Ok(self.as_internal().get_type()?.clone()) + Ok(self.0.get_type()?.clone()) } /// When we know the value isn't `Sort`, this gets the type directly pub(crate) fn get_type_not_sort(&self) -> Value { @@ -387,9 +371,7 @@ impl Value { }), }; - let self_ty = self.as_internal().ty.clone(); - let self_span = self.as_internal().span.clone(); - TyExpr::new(tye, self_ty, self_span) + TyExpr::new(tye, self.0.ty.clone(), self.0.span.clone()) } pub fn to_tyexpr_noenv(&self) -> TyExpr { self.to_tyexpr(VarEnv::new()) @@ -397,17 +379,48 @@ impl Value { } impl ValueInternal { + fn new(form: Form, ty: Option, span: Span) -> Self { + ValueInternal { + form: RefCell::new(form), + ty, + span, + } + } fn into_value(self) -> Value { - Value(Rc::new(RefCell::new(self))) + Value(Rc::new(self)) } - fn normalize_whnf(&mut self) { + fn normalize_whnf(&self) { + if !self.form.borrow().is_whnf() { + self.form.borrow_mut().normalize_whnf(&self.ty) + } + } + fn normalize_nf(&self) { + self.form.borrow_mut().normalize_nf(&self.ty) + } + + fn get_type(&self) -> Result<&Value, TypeError> { + match &self.ty { + Some(t) => Ok(t), + None => Err(TypeError::new(TypeMessage::Sort)), + } + } +} + +impl Form { + fn is_whnf(&self) -> bool { + match self { + Form::Thunk(..) | Form::PartialExpr(..) => false, + Form::WHNF(..) => true, + } + } + fn normalize_whnf(&mut self, ty: &Option) { use std::mem::replace; let dummy = Form::PartialExpr(ExprKind::Const(Const::Type)); - self.form = match replace(&mut self.form, dummy) { + *self = match replace(self, dummy) { Form::Thunk(th) => Form::WHNF(th.eval()), Form::PartialExpr(e) => { - Form::WHNF(match &self.ty { + Form::WHNF(match ty { // TODO: env Some(ty) => normalize_one_layer(e, &ty, &NzEnv::new()), // `value` is `Sort` @@ -418,22 +431,15 @@ impl ValueInternal { form @ Form::WHNF(_) => form, }; } - fn normalize_nf(&mut self) { - if let Form::Thunk(..) | Form::PartialExpr(_) = self.form { - self.normalize_whnf(); + fn normalize_nf(&mut self, ty: &Option) { + if !self.is_whnf() { + self.normalize_whnf(ty); } - match &mut self.form { + match self { Form::Thunk(..) | Form::PartialExpr(_) => unreachable!(), Form::WHNF(k) => k.normalize_mut(), } } - - fn get_type(&self) -> Result<&Value, TypeError> { - match &self.ty { - Some(t) => Ok(t), - None => Err(TypeError::new(TypeMessage::Sort)), - } - } } impl ValueKind { @@ -665,8 +671,8 @@ impl std::cmp::Eq for Closure {} impl std::fmt::Debug for Value { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - let vint: &ValueInternal = &self.as_internal(); - let mut x = match &vint.form { + let vint: &ValueInternal = &self.0; + let mut x = match &*vint.form.borrow() { Form::Thunk(th) => { let mut x = fmt.debug_struct(&format!("Value@Thunk")); x.field("thunk", th); -- cgit v1.2.3