diff options
Diffstat (limited to '')
| -rw-r--r-- | dhall/src/binary.rs | 3 | ||||
| -rw-r--r-- | dhall/src/normalize.rs | 1 | ||||
| -rw-r--r-- | dhall/src/typecheck.rs | 13 | ||||
| -rw-r--r-- | dhall_core/src/core.rs | 80 | ||||
| -rw-r--r-- | dhall_core/src/parser.rs | 67 | ||||
| -rw-r--r-- | dhall_generator/src/lib.rs | 15 |
6 files changed, 93 insertions, 86 deletions
diff --git a/dhall/src/binary.rs b/dhall/src/binary.rs index fbd343b..08bdba4 100644 --- a/dhall/src/binary.rs +++ b/dhall/src/binary.rs @@ -1,8 +1,9 @@ use dhall_core::*; use itertools::*; +use std::rc::Rc; use serde_cbor::value::value as cbor; -type ParsedExpr = Box<Expr<X, Import>>; +type ParsedExpr = Rc<Expr<X, Import>>; #[derive(Debug)] pub enum DecodeError { diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs index c49d313..40112f1 100644 --- a/dhall/src/normalize.rs +++ b/dhall/src/normalize.rs @@ -2,6 +2,7 @@ use dhall_core::core::*; use dhall_generator::dhall_expr; use std::fmt; +use std::rc::Rc; /// Reduce an expression to its weak head normal form, i.e. normalize /// just enough to get the first constructor of the final expression diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs index ca0d5af..f5670f7 100644 --- a/dhall/src/typecheck.rs +++ b/dhall/src/typecheck.rs @@ -2,6 +2,7 @@ use std::collections::BTreeMap; use std::collections::HashSet; use std::fmt; +use std::rc::Rc; use crate::normalize; use dhall_core::context::Context; @@ -415,7 +416,7 @@ where } ListLit(ref t, ref xs) => { let mut iter = xs.iter().enumerate(); - let t: Box<Expr<_, _>> = match t { + let t: Rc<Expr<_, _>> = match t { Some(t) => t.clone(), None => { let (_, first_x) = iter.next().unwrap(); @@ -426,7 +427,7 @@ where let s = normalize::<_, S, _>(&type_with(ctx, &t)?); match s { Const(Type) => {} - _ => return Err(TypeError::new(ctx, e, InvalidListType(*t))), + _ => return Err(TypeError::new(ctx, e, InvalidListType(t))), } for (i, x) in iter { let t2 = type_with(ctx, x)?; @@ -474,7 +475,7 @@ where )), OptionalLit(ref t, ref xs) => { let mut iter = xs.iter(); - let t: Box<Expr<_, _>> = match t { + let t: Rc<Expr<_, _>> = match t { Some(t) => t.clone(), None => { let x = iter.next().unwrap(); @@ -489,7 +490,7 @@ where return Err(TypeError::new( ctx, e, - InvalidOptionalType(*t), + InvalidOptionalType(t), )); } } @@ -689,10 +690,10 @@ pub enum TypeMessage<S> { AnnotMismatch(Expr<S, X>, Expr<S, X>, Expr<S, X>), Untyped, InvalidListElement(usize, Expr<S, X>, Expr<S, X>, Expr<S, X>), - InvalidListType(Expr<S, X>), + InvalidListType(Rc<Expr<S, X>>), InvalidOptionalElement(Expr<S, X>, Expr<S, X>, Expr<S, X>), InvalidOptionalLiteral(usize), - InvalidOptionalType(Expr<S, X>), + InvalidOptionalType(Rc<Expr<S, X>>), InvalidPredicate(Expr<S, X>, Expr<S, X>), IfBranchMismatch(Expr<S, X>, Expr<S, X>, Expr<S, X>, Expr<S, X>), IfBranchMustBeTerm(bool, Expr<S, X>, Expr<S, X>, Expr<S, X>), diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs index 34738bb..f5da1df 100644 --- a/dhall_core/src/core.rs +++ b/dhall_core/src/core.rs @@ -176,13 +176,13 @@ pub enum BinOp { #[derive(Debug, Clone, PartialEq)] pub struct InterpolatedText<Note, Embed> { head: String, - tail: Vec<(Box<Expr<Note, Embed>>, String)>, + tail: Vec<(Rc<Expr<Note, Embed>>, String)>, } -impl<N, E> From<(String, Vec<(Box<Expr<N, E>>, String)>)> +impl<N, E> From<(String, Vec<(Rc<Expr<N, E>>, String)>)> for InterpolatedText<N, E> { - fn from(x: (String, Vec<(Box<Expr<N, E>>, String)>)) -> Self { + fn from(x: (String, Vec<(Rc<Expr<N, E>>, String)>)) -> Self { InterpolatedText { head: x.0, tail: x.1, @@ -203,7 +203,7 @@ impl<N, E> From<String> for InterpolatedText<N, E> { // This one is needed when parsing, because we need to own the Expr pub enum OwnedInterpolatedTextContents<'a, Note, Embed> { Text(&'a str), - Expr(Box<Expr<Note, Embed>>), + Expr(Rc<Expr<Note, Embed>>), } // This one is needed everywhere else, because we don't want Clone traits bounds @@ -231,7 +231,7 @@ impl<'a, N: Clone + 'a, E: Clone + 'a> impl<N, E> InterpolatedText<N, E> { pub fn map<N2, E2, F>(&self, mut f: F) -> InterpolatedText<N2, E2> where - F: FnMut(&Box<Expr<N, E>>) -> Box<Expr<N2, E2>>, + F: FnMut(&Rc<Expr<N, E>>) -> Rc<Expr<N2, E2>>, { InterpolatedText { head: self.head.clone(), @@ -299,33 +299,33 @@ pub enum Expr<Note, Embed> { /// `Var (V x n) ~ x@n` Var(V), /// `Lam x A b ~ λ(x : A) -> b` - Lam(Label, Box<Expr<Note, Embed>>, Box<Expr<Note, Embed>>), + Lam(Label, Rc<Expr<Note, Embed>>, Rc<Expr<Note, Embed>>), /// `Pi "_" A B ~ A -> B` /// `Pi x A B ~ ∀(x : A) -> B` - Pi(Label, Box<Expr<Note, Embed>>, Box<Expr<Note, Embed>>), + Pi(Label, Rc<Expr<Note, Embed>>, Rc<Expr<Note, Embed>>), /// `App f A ~ f A` - App(Box<Expr<Note, Embed>>, Vec<Box<Expr<Note, Embed>>>), + App(Rc<Expr<Note, Embed>>, Vec<Rc<Expr<Note, Embed>>>), /// `Let x Nothing r e ~ let x = r in e` /// `Let x (Just t) r e ~ let x : t = r in e` Let( Label, - Option<Box<Expr<Note, Embed>>>, - Box<Expr<Note, Embed>>, - Box<Expr<Note, Embed>>, + Option<Rc<Expr<Note, Embed>>>, + Rc<Expr<Note, Embed>>, + Rc<Expr<Note, Embed>>, ), /// `Annot x t ~ x : t` - Annot(Box<Expr<Note, Embed>>, Box<Expr<Note, Embed>>), + Annot(Rc<Expr<Note, Embed>>, Rc<Expr<Note, Embed>>), /// Built-in values Builtin(Builtin), // Binary operations - BinOp(BinOp, Box<Expr<Note, Embed>>, Box<Expr<Note, Embed>>), + BinOp(BinOp, Rc<Expr<Note, Embed>>, Rc<Expr<Note, Embed>>), /// `BoolLit b ~ b` BoolLit(bool), /// `BoolIf x y z ~ if x then y else z` BoolIf( - Box<Expr<Note, Embed>>, - Box<Expr<Note, Embed>>, - Box<Expr<Note, Embed>>, + Rc<Expr<Note, Embed>>, + Rc<Expr<Note, Embed>>, + Rc<Expr<Note, Embed>>, ), /// `NaturalLit n ~ +n` NaturalLit(Natural), @@ -336,35 +336,35 @@ pub enum Expr<Note, Embed> { /// `TextLit t ~ t` TextLit(InterpolatedText<Note, Embed>), /// `ListLit t [x, y, z] ~ [x, y, z] : List t` - ListLit(Option<Box<Expr<Note, Embed>>>, Vec<Box<Expr<Note, Embed>>>), + ListLit(Option<Rc<Expr<Note, Embed>>>, Vec<Rc<Expr<Note, Embed>>>), /// `OptionalLit t [e] ~ [e] : Optional t` /// `OptionalLit t [] ~ [] : Optional t` OptionalLit( - Option<Box<Expr<Note, Embed>>>, - Option<Box<Expr<Note, Embed>>>, + Option<Rc<Expr<Note, Embed>>>, + Option<Rc<Expr<Note, Embed>>>, ), /// `Record [(k1, t1), (k2, t2)] ~ { k1 : t1, k2 : t1 }` - Record(BTreeMap<Label, Box<Expr<Note, Embed>>>), + Record(BTreeMap<Label, Rc<Expr<Note, Embed>>>), /// `RecordLit [(k1, v1), (k2, v2)] ~ { k1 = v1, k2 = v2 }` - RecordLit(BTreeMap<Label, Box<Expr<Note, Embed>>>), + RecordLit(BTreeMap<Label, Rc<Expr<Note, Embed>>>), /// `Union [(k1, t1), (k2, t2)] ~ < k1 : t1, k2 : t2 >` - Union(BTreeMap<Label, Box<Expr<Note, Embed>>>), + Union(BTreeMap<Label, Rc<Expr<Note, Embed>>>), /// `UnionLit (k1, v1) [(k2, t2), (k3, t3)] ~ < k1 = t1, k2 : t2, k3 : t3 >` UnionLit( Label, - Box<Expr<Note, Embed>>, - BTreeMap<Label, Box<Expr<Note, Embed>>>, + Rc<Expr<Note, Embed>>, + BTreeMap<Label, Rc<Expr<Note, Embed>>>, ), /// `Merge x y t ~ merge x y : t` Merge( - Box<Expr<Note, Embed>>, - Box<Expr<Note, Embed>>, - Option<Box<Expr<Note, Embed>>>, + Rc<Expr<Note, Embed>>, + Rc<Expr<Note, Embed>>, + Option<Rc<Expr<Note, Embed>>>, ), /// `Field e x ~ e.x` - Field(Box<Expr<Note, Embed>>, Label), + Field(Rc<Expr<Note, Embed>>, Label), /// Annotation on the AST. Unused for now but could hold e.g. file location information - Note(Note, Box<Expr<Note, Embed>>), + Note(Note, Rc<Expr<Note, Embed>>), /// Embeds an import or the result of resolving the import Embed(Embed), } @@ -848,14 +848,13 @@ where Expr::Pi(var.into(), bx(ty.into()), bx(value.into())) } -pub fn app<S, A, Ef, Ex>(f: Ef, x: Vec<Box<Ex>>) -> Expr<S, A> +pub fn app<S, A, Ef>(f: Ef, x: Vec<Rc<Expr<S, A>>>) -> Expr<S, A> where Ef: Into<Expr<S, A>>, - Ex: Into<Expr<S, A>>, { Expr::App( bx(f.into()), - x.into_iter().map(|x| bx((*x).into())).collect(), + x, ) } @@ -874,8 +873,11 @@ impl Display for X { } } -pub fn bx<T>(x: T) -> Box<T> { - Box::new(x) +pub fn bx<T>(x: T) -> Rc<T> { + Rc::new(x) +} +pub fn rc<T>(x: T) -> Rc<T> { + Rc::new(x) } fn add_ui(u: usize, i: isize) -> usize { @@ -904,8 +906,8 @@ where F4: Fn(&Label) -> Label, { use crate::Expr::*; - let bxmap = |x: &Expr<S, A>| -> Box<Expr<T, B>> { bx(map(x)) }; - let bxbxmap = |x: &Box<Expr<S, A>>| -> Box<Expr<T, B>> { bx(map(&**x)) }; + let bxmap = |x: &Expr<S, A>| -> Rc<Expr<T, B>> { bx(map(x)) }; + let bxbxmap = |x: &Rc<Expr<S, A>>| -> Rc<Expr<T, B>> { bx(map(&**x)) }; let opt = |x| map_opt_box(x, &map); match *e { Const(k) => Const(k), @@ -980,7 +982,7 @@ where it.into_iter().map(|(k, v)| (g(k), f(v))).collect() } -pub fn map_opt_box<T, U, F>(x: &Option<Box<T>>, f: F) -> Option<Box<U>> +pub fn map_opt_box<T, U, F>(x: &Option<Rc<T>>, f: F) -> Option<Rc<U>> where F: FnOnce(&T) -> U, { @@ -1153,7 +1155,7 @@ fn shift_op2<S, T, A, F>( b: &Expr<S, A>, ) -> Expr<T, A> where - F: FnOnce(Box<Expr<T, A>>, Box<Expr<T, A>>) -> Expr<T, A>, + F: FnOnce(Rc<Expr<T, A>>, Rc<Expr<T, A>>) -> Expr<T, A>, A: Clone, { map_op2(f, |x| bx(shift(d, v, x)), a, b) @@ -1258,7 +1260,7 @@ fn subst_op2<S, T, A, F>( b: &Expr<T, A>, ) -> Expr<S, A> where - F: FnOnce(Box<Expr<S, A>>, Box<Expr<S, A>>) -> Expr<S, A>, + F: FnOnce(Rc<Expr<S, A>>, Rc<Expr<S, A>>) -> Expr<S, A>, S: Clone, A: Clone, { diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs index b2955fb..682e081 100644 --- a/dhall_core/src/parser.rs +++ b/dhall_core/src/parser.rs @@ -2,6 +2,7 @@ use pest::iterators::Pair; use pest::Parser; use std::collections::BTreeMap; use std::path::PathBuf; +use std::rc::Rc; use dhall_parser::{DhallParser, Rule}; @@ -16,7 +17,7 @@ use crate::core::*; pub type ParsedExpr = Expr<X, Import>; pub type ParsedText = InterpolatedText<X, Import>; pub type ParsedTextContents<'a> = OwnedInterpolatedTextContents<'a, X, Import>; -pub type BoxExpr = Box<ParsedExpr>; +pub type RcExpr = Rc<ParsedExpr>; pub type ParseError = pest::error::Error<Rule>; @@ -455,7 +456,7 @@ rule!(escaped_quote_pair<&'a str>; rule!(escaped_interpolation<&'a str>; children!() => "${" ); -rule!(interpolation<BoxExpr>; +rule!(interpolation<RcExpr>; children!(e: expression) => e ); @@ -556,7 +557,7 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>; } ); -rule!(import_raw<BoxExpr>; +rule!(import_raw<RcExpr>; // TODO: handle "as Text" children!(import: import_hashed_raw) => { let (location, hash) = import; @@ -568,7 +569,7 @@ rule!(import_raw<BoxExpr>; } ); -rule_group!(expression<BoxExpr>; +rule_group!(expression<RcExpr>; identifier_raw, lambda_expression, ifthenelse_expression, @@ -605,47 +606,47 @@ rule_group!(expression<BoxExpr>; final_expression ); -rule!(lambda_expression<BoxExpr>; +rule!(lambda_expression<RcExpr>; children!(l: label, typ: expression, body: expression) => { bx(Expr::Lam(l, typ, body)) } ); -rule!(ifthenelse_expression<BoxExpr>; +rule!(ifthenelse_expression<RcExpr>; children!(cond: expression, left: expression, right: expression) => { bx(Expr::BoolIf(cond, left, right)) } ); -rule!(let_expression<BoxExpr>; +rule!(let_expression<RcExpr>; children!(bindings*: let_binding, final_expr: expression) => { bindings.fold(final_expr, |acc, x| bx(Expr::Let(x.0, x.1, x.2, acc))) } ); -rule!(let_binding<(Label, Option<BoxExpr>, BoxExpr)>; +rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>; children!(name: label, annot?: expression, expr: expression) => (name, annot, expr) ); -rule!(forall_expression<BoxExpr>; +rule!(forall_expression<RcExpr>; children!(l: label, typ: expression, body: expression) => { bx(Expr::Pi(l, typ, body)) } ); -rule!(arrow_expression<BoxExpr>; +rule!(arrow_expression<RcExpr>; children!(typ: expression, body: expression) => { bx(Expr::Pi("_".into(), typ, body)) } ); -rule!(merge_expression<BoxExpr>; +rule!(merge_expression<RcExpr>; children!(x: expression, y: expression, z?: expression) => { bx(Expr::Merge(x, y, z)) } ); -rule!(empty_collection<BoxExpr>; +rule!(empty_collection<RcExpr>; children!(x: str, y: expression) => { match x { "Optional" => bx(Expr::OptionalLit(Some(y), None)), @@ -655,7 +656,7 @@ rule!(empty_collection<BoxExpr>; } ); -rule!(non_empty_optional<BoxExpr>; +rule!(non_empty_optional<RcExpr>; children!(x: expression, _y: str, z: expression) => { bx(Expr::OptionalLit(Some(z), Some(x))) } @@ -686,7 +687,7 @@ fn can_be_shortcutted(rule: Rule) -> bool { macro_rules! binop { ($rule:ident, $op:ident) => { - rule!($rule<BoxExpr>; + rule!($rule<RcExpr>; raw_pair!(pair) => { // This all could be a trivial fold, but to avoid stack explosion // we try to cut down on the recursion level here, by consuming @@ -737,14 +738,14 @@ binop!(times_expression, NaturalTimes); binop!(equal_expression, BoolEQ); binop!(not_equal_expression, BoolNE); -rule!(annotated_expression<BoxExpr>; +rule!(annotated_expression<RcExpr>; children!(e: expression, annot: expression) => { bx(Expr::Annot(e, annot)) }, children!(e: expression) => e, ); -rule!(application_expression<BoxExpr>; +rule!(application_expression<RcExpr>; children!(first: expression, rest*: expression) => { let rest: Vec<_> = rest.collect(); if rest.is_empty() { @@ -755,13 +756,13 @@ rule!(application_expression<BoxExpr>; } ); -rule!(selector_expression_raw<BoxExpr>; +rule!(selector_expression_raw<RcExpr>; children!(first: expression, rest*: label) => { rest.fold(first, |acc, e| bx(Expr::Field(acc, e))) } ); -rule!(literal_expression_raw<BoxExpr>; +rule!(literal_expression_raw<RcExpr>; children!(n: double_literal_raw) => bx(Expr::DoubleLit(n)), children!(n: minus_infinity_literal) => bx(Expr::DoubleLit(std::f64::NEG_INFINITY)), children!(n: plus_infinity_literal) => bx(Expr::DoubleLit(std::f64::INFINITY)), @@ -773,7 +774,7 @@ rule!(literal_expression_raw<BoxExpr>; children!(e: expression) => e, ); -rule!(identifier_raw<BoxExpr>; +rule!(identifier_raw<RcExpr>; children!(name: str, idx?: natural_literal_raw) => { match Builtin::parse(name) { Some(b) => bx(Expr::Builtin(b)), @@ -788,15 +789,15 @@ rule!(identifier_raw<BoxExpr>; } ); -rule!(empty_record_literal<BoxExpr>; +rule!(empty_record_literal<RcExpr>; children!() => bx(Expr::RecordLit(BTreeMap::new())) ); -rule!(empty_record_type<BoxExpr>; +rule!(empty_record_type<RcExpr>; children!() => bx(Expr::Record(BTreeMap::new())) ); -rule!(non_empty_record_type_or_literal<BoxExpr>; +rule!(non_empty_record_type_or_literal<RcExpr>; children!(first_label: label, rest: non_empty_record_type) => { let (first_expr, mut map) = rest; map.insert(first_label, first_expr); @@ -809,25 +810,25 @@ rule!(non_empty_record_type_or_literal<BoxExpr>; }, ); -rule!(non_empty_record_type<(BoxExpr, BTreeMap<Label, BoxExpr>)>; +rule!(non_empty_record_type<(RcExpr, BTreeMap<Label, RcExpr>)>; self!(x: partial_record_entries) => x ); -named!(partial_record_entries<(BoxExpr, BTreeMap<Label, BoxExpr>)>; +named!(partial_record_entries<(RcExpr, BTreeMap<Label, RcExpr>)>; children!(expr: expression, entries*: record_entry) => { (expr, entries.collect()) } ); -named!(record_entry<(Label, BoxExpr)>; +named!(record_entry<(Label, RcExpr)>; children!(name: label, expr: expression) => (name, expr) ); -rule!(non_empty_record_literal<(BoxExpr, BTreeMap<Label, BoxExpr>)>; +rule!(non_empty_record_literal<(RcExpr, BTreeMap<Label, RcExpr>)>; self!(x: partial_record_entries) => x ); -rule!(union_type_or_literal<BoxExpr>; +rule!(union_type_or_literal<RcExpr>; children!(_e: empty_union_type) => { bx(Expr::Union(BTreeMap::new())) }, @@ -842,7 +843,7 @@ rule!(union_type_or_literal<BoxExpr>; rule!(empty_union_type<()>; children!() => ()); rule!(non_empty_union_type_or_literal - <(Option<(Label, BoxExpr)>, BTreeMap<Label, BoxExpr>)>; + <(Option<(Label, RcExpr)>, BTreeMap<Label, RcExpr>)>; children!(l: label, e: expression, entries: union_type_entries) => { (Some((l, e)), entries) }, @@ -858,27 +859,27 @@ rule!(non_empty_union_type_or_literal }, ); -rule!(union_type_entries<BTreeMap<Label, BoxExpr>>; +rule!(union_type_entries<BTreeMap<Label, RcExpr>>; children!(entries*: union_type_entry) => { entries.collect() } ); -rule!(union_type_entry<(Label, BoxExpr)>; +rule!(union_type_entry<(Label, RcExpr)>; children!(name: label, expr: expression) => (name, expr) ); -rule!(non_empty_list_literal_raw<BoxExpr>; +rule!(non_empty_list_literal_raw<RcExpr>; children!(items*: expression) => { bx(Expr::ListLit(None, items.collect())) } ); -rule!(final_expression<BoxExpr>; +rule!(final_expression<RcExpr>; children!(e: expression, _eoi: EOI) => e ); -pub fn parse_expr(s: &str) -> ParseResult<BoxExpr> { +pub fn parse_expr(s: &str) -> ParseResult<RcExpr> { let pairs = DhallParser::parse(Rule::final_expression, s)?; // Match the only item in the pairs iterator // println!("{}", debug_pair(pairs.clone().next().unwrap())); diff --git a/dhall_generator/src/lib.rs b/dhall_generator/src/lib.rs index 1a74f4f..26be4c4 100644 --- a/dhall_generator/src/lib.rs +++ b/dhall_generator/src/lib.rs @@ -4,11 +4,12 @@ use dhall_core::*; use proc_macro2::TokenStream; use quote::quote; use std::collections::BTreeMap; +use std::rc::Rc; #[proc_macro] pub fn dhall_expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input_str = input.to_string(); - let expr: Box<Expr<X, Import>> = parser::parse_expr(&input_str).unwrap(); + let expr: Rc<Expr<X, Import>> = parser::parse_expr(&input_str).unwrap(); let no_import = |_: &Import| -> X { panic!("Don't use import in dhall!()") }; let expr = expr.map_embed(&no_import); @@ -17,7 +18,7 @@ pub fn dhall_expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { } // Returns an expression of type Expr<_, _>. Expects input variables -// to be of type Box<Expr<_, _>> (future-proof for structural sharing). +// to be of type Rc<Expr<_, _>>. fn dhall_to_tokenstream( expr: &Expr<X, X>, ctx: &Context<Label, ()>, @@ -77,7 +78,7 @@ fn dhall_to_tokenstream( } } -// Returns an expression of type Box<Expr<_, _>> +// Returns an expression of type Rc<Expr<_, _>> fn dhall_to_tokenstream_bx( expr: &Expr<X, X>, ctx: &Context<Label, ()>, @@ -97,7 +98,7 @@ fn dhall_to_tokenstream_bx( // TODO: insert appropriate shifts ? let v: TokenStream = s.parse().unwrap(); quote! { { - let x: Box<Expr<_, _>> = #v.clone(); + let x: Rc<Expr<_, _>> = #v.clone(); x } } } @@ -125,7 +126,7 @@ fn label_to_tokenstream(l: &Label) -> TokenStream { } fn map_to_tokenstream( - m: &BTreeMap<Label, Box<Expr<X, X>>>, + m: &BTreeMap<Label, Rc<Expr<X, X>>>, ctx: &Context<Label, ()>, ) -> TokenStream { let (keys, values): (Vec<TokenStream>, Vec<TokenStream>) = m @@ -142,7 +143,7 @@ fn map_to_tokenstream( } fn option_to_tokenstream( - e: &Option<Box<Expr<X, X>>>, + e: &Option<Rc<Expr<X, X>>>, ctx: &Context<Label, ()>, ) -> TokenStream { let e = e.as_ref().map(|x| dhall_to_tokenstream_bx(x, ctx)); @@ -153,7 +154,7 @@ fn option_to_tokenstream( } fn vec_to_tokenstream( - e: &Vec<Box<Expr<X, X>>>, + e: &Vec<Rc<Expr<X, X>>>, ctx: &Context<Label, ()>, ) -> TokenStream { let e = e.iter().map(|x| dhall_to_tokenstream_bx(&**x, ctx)); |