waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: use Rc for more things, fib_iter runs almost 3 seconds faster now

This commit is contained in:
rvcas 2023-01-31 03:30:45 -05:00 committed by Lucas
parent eda3194cf0
commit c8efe60843
15 changed files with 1789 additions and 1110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
crates/aiken-lang/src/builder.rs
View File

@ -1,4 +1,4 @@
use std::{cell::RefCell, sync::Arc};
use std::{cell::RefCell, rc::Rc, sync::Arc};
use indexmap::{IndexMap, IndexSet};
use itertools::Itertools;
@ -186,7 +186,8 @@ pub fn convert_type_to_data(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
parameter_name: Name {
text: "__pair".to_string(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
DefaultFunction::ListData.into(),
apply_wrap(
@ -196,10 +197,13 @@ pub fn convert_type_to_data(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
Term::Builtin(DefaultFunction::FstPair)
.force_wrap()
.force_wrap(),
Term::Var(Name {
text: "__pair".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "__pair".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
apply_wrap(
@ -209,13 +213,16 @@ pub fn convert_type_to_data(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
Term::Builtin(DefaultFunction::SndPair)
.force_wrap()
.force_wrap(),
Term::Var(Name {
text: "__pair".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "__pair".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
Term::Constant(UplcConstant::ProtoList(UplcType::Data, vec![])),
Term::Constant(UplcConstant::ProtoList(UplcType::Data, vec![]).into()),
),
),
)
@ -228,16 +235,22 @@ pub fn convert_type_to_data(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
} else if field_type.is_bool() {
if_else(
term,
Term::Constant(UplcConstant::Data(PlutusData::Constr(Constr {
tag: convert_constr_to_tag(1),
any_constructor: None,
fields: vec![],
}))),
Term::Constant(UplcConstant::Data(PlutusData::Constr(Constr {
tag: convert_constr_to_tag(0),
any_constructor: None,
fields: vec![],
}))),
Term::Constant(
UplcConstant::Data(PlutusData::Constr(Constr {
tag: convert_constr_to_tag(1),
any_constructor: None,
fields: vec![],
}))
.into(),
),
Term::Constant(
UplcConstant::Data(PlutusData::Constr(Constr {
tag: convert_constr_to_tag(0),
any_constructor: None,
fields: vec![],
}))
.into(),
),
)
} else {
term
@ -262,40 +275,51 @@ pub fn convert_data_to_type(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
parameter_name: Name {
text: "__list_data".to_string(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: "__tail".to_string(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
apply_wrap(
Term::Builtin(DefaultFunction::MkPairData),
apply_wrap(
Term::Builtin(DefaultFunction::HeadList).force_wrap(),
Term::Var(Name {
text: "__list_data".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "__list_data".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
apply_wrap(
Term::Builtin(DefaultFunction::HeadList).force_wrap(),
Term::Var(Name {
text: "__tail".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "__tail".to_string(),
unique: 0.into(),
}
.into(),
),
),
)
.into(),
},
apply_wrap(
Term::Builtin(DefaultFunction::TailList).force_wrap(),
Term::Var(Name {
text: "__list_data".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "__list_data".to_string(),
unique: 0.into(),
}
.into(),
),
),
)
.into(),
@ -308,7 +332,7 @@ pub fn convert_data_to_type(term: Term<Name>, field_type: &Arc<Type>) -> Term<Na
apply_wrap(
apply_wrap(
DefaultFunction::EqualsInteger.into(),
Term::Constant(UplcConstant::Integer(1)),
Term::Constant(UplcConstant::Integer(1).into()),
),
apply_wrap(
Term::Builtin(DefaultFunction::FstPair)
@ -493,19 +517,28 @@ pub fn list_access_to_uplc(
let head_list = if current_tipo.is_map() {
apply_wrap(
Term::Builtin(DefaultFunction::HeadList).force_wrap(),
Term::Var(Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
}),
Term::Var(
Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
}
.into(),
),
)
} else {
convert_data_to_type(
apply_wrap(
Term::Builtin(DefaultFunction::HeadList).force_wrap(),
Term::Var(Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
}),
Term::Var(
Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}
.into(),
),
),
&current_tipo.to_owned(),
)
@ -516,30 +549,36 @@ pub fn list_access_to_uplc(
parameter_name: Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: first.clone(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: names[0].clone(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
},
apply_wrap(
Term::Builtin(DefaultFunction::TailList).force_wrap(),
Term::Var(Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}),
Term::Var(
Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}
.into(),
),
),
)
.into(),
@ -553,33 +592,41 @@ pub fn list_access_to_uplc(
parameter_name: Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: first.clone(),
unique: 0.into(),
},
}
.into(),
body: if check_last_item {
delayed_choose_list(
apply_wrap(
Term::Builtin(DefaultFunction::TailList).force_wrap(),
Term::Var(Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}),
Term::Var(
Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}
.into(),
),
),
term,
apply_wrap(
apply_wrap(
Term::Builtin(DefaultFunction::Trace).force_wrap(),
Term::Constant(UplcConstant::String(
"List/Tuple contains more items than it should"
.to_string(),
)),
Term::Constant(
UplcConstant::String(
"List/Tuple contains more items than it should"
.to_string(),
)
.into(),
),
),
Term::Delay(Term::Error.into()),
)
@ -599,13 +646,15 @@ pub fn list_access_to_uplc(
parameter_name: Name {
text: format!("tail_index_{}_{}", current_index, id_list[current_index]),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: first.clone(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
list_access_to_uplc(
names,
@ -618,13 +667,16 @@ pub fn list_access_to_uplc(
),
apply_wrap(
Term::Builtin(DefaultFunction::TailList).force_wrap(),
Term::Var(Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}),
Term::Var(
Name {
text: format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
),
unique: 0.into(),
}
.into(),
),
),
)
.into(),
@ -935,38 +987,39 @@ pub fn get_variant_name(new_name: &mut String, t: &Arc<Type>) {
});
}
pub fn convert_constants_to_data(constants: Vec<UplcConstant>) -> Vec<UplcConstant> {
pub fn convert_constants_to_data(constants: Vec<Rc<UplcConstant>>) -> Vec<UplcConstant> {
let mut new_constants = vec![];
for constant in constants {
let constant = match constant {
let constant = match constant.as_ref() {
UplcConstant::Integer(i) => {
UplcConstant::Data(PlutusData::BigInt(BigInt::Int((i).try_into().unwrap())))
UplcConstant::Data(PlutusData::BigInt(BigInt::Int((*i).try_into().unwrap())))
}
UplcConstant::ByteString(b) => {
UplcConstant::Data(PlutusData::BoundedBytes(b.try_into().unwrap()))
UplcConstant::Data(PlutusData::BoundedBytes(b.clone().try_into().unwrap()))
}
UplcConstant::String(s) => UplcConstant::Data(PlutusData::BoundedBytes(
s.as_bytes().to_vec().try_into().unwrap(),
)),
UplcConstant::Bool(b) => UplcConstant::Data(PlutusData::Constr(Constr {
tag: convert_constr_to_tag(b.into()),
tag: convert_constr_to_tag((*b).into()),
any_constructor: None,
fields: vec![],
})),
UplcConstant::ProtoList(_, constants) => {
let inner_constants = convert_constants_to_data(constants)
.into_iter()
.map(|constant| match constant {
UplcConstant::Data(d) => d,
_ => todo!(),
})
.collect_vec();
let inner_constants =
convert_constants_to_data(constants.iter().cloned().map(Rc::new).collect())
.into_iter()
.map(|constant| match constant {
UplcConstant::Data(d) => d,
_ => todo!(),
})
.collect_vec();
UplcConstant::Data(PlutusData::Array(inner_constants))
}
UplcConstant::ProtoPair(_, _, left, right) => {
let inner_constants = vec![*left, *right];
let inner_constants = vec![left.clone(), right.clone()];
let inner_constants = convert_constants_to_data(inner_constants)
.into_iter()
.map(|constant| match constant {
@ -980,7 +1033,7 @@ pub fn convert_constants_to_data(constants: Vec<UplcConstant>) -> Vec<UplcConsta
inner_constants[1].clone(),
)])))
}
d @ UplcConstant::Data(_) => d,
d @ UplcConstant::Data(_) => d.clone(),
_ => unreachable!(),
};
new_constants.push(constant);
@ -997,14 +1050,18 @@ pub fn wrap_validator_args(term: Term<Name>, arguments: &[TypedArg]) -> Term<Nam
parameter_name: Name {
text: arg.arg_name.get_variable_name().unwrap_or("_").to_string(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
},
convert_data_to_type(
Term::Var(Name {
text: arg.arg_name.get_variable_name().unwrap_or("_").to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: arg.arg_name.get_variable_name().unwrap_or("_").to_string(),
unique: 0.into(),
}
.into(),
),
&arg.tipo,
),
);
@ -1014,7 +1071,8 @@ pub fn wrap_validator_args(term: Term<Name>, arguments: &[TypedArg]) -> Term<Nam
parameter_name: Name {
text: arg.arg_name.get_variable_name().unwrap_or("_").to_string(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
}
}

1022
crates/aiken-lang/src/uplc.rs
View File

File diff suppressed because it is too large Load Diff

2
crates/aiken-project/src/lib.rs
View File

@ -655,7 +655,7 @@ where
.map(|script| match script.program.eval(initial_budget) {
(Ok(result), remaining_budget, logs) => EvalInfo {
success: result != Term::Error
&& result != Term::Constant(Constant::Bool(false)),
&& result != Term::Constant(Constant::Bool(false).into()),
script,
spent_budget: initial_budget - remaining_budget,
output: Some(result),

8
crates/uplc/src/ast.rs
View File

@ -74,7 +74,7 @@ where
pub fn apply_data(&self, plutus_data: PlutusData) -> Self {
let applied_term = Term::Apply {
function: Rc::new(self.term.clone()),
argument: Rc::new(Term::Constant(Constant::Data(plutus_data))),
argument: Rc::new(Term::Constant(Constant::Data(plutus_data).into())),
};
Program {
@ -239,7 +239,7 @@ pub enum Constant {
// tag: 5
ProtoList(Type, Vec<Constant>),
// tag: 6
ProtoPair(Type, Type, Box<Constant>, Box<Constant>),
ProtoPair(Type, Type, Rc<Constant>, Rc<Constant>),
// tag: 7
// Apply(Box<Constant>, Type),
// tag: 8
@ -253,8 +253,8 @@ pub enum Type {
String,
ByteString,
Unit,
List(Box<Type>),
Pair(Box<Type>, Box<Type>),
List(Rc<Type>),
Pair(Rc<Type>, Rc<Type>),
Data,
}

278
crates/uplc/src/ast/builder.rs
View File

@ -23,7 +23,7 @@ pub fn final_wrapper(term: Term<Name>) -> Term<Name> {
argument: term.into(),
}
.into(),
argument: Term::Delay(Term::Constant(Constant::Unit).into()).into(),
argument: Term::Delay(Term::Constant(Constant::Unit.into()).into()).into(),
}
.into(),
argument: Term::Delay(Term::Error.into()).into(),
@ -38,24 +38,32 @@ pub fn assert_on_list(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
},
}
.into(),
body: apply_wrap(
Term::Lambda {
parameter_name: Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
},
apply_wrap(
Term::Var(Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}),
Term::Var(Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}
.into(),
),
Term::Var(
Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}
.into(),
),
),
)
.into(),
@ -64,64 +72,88 @@ pub fn assert_on_list(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Lambda {
parameter_name: Name {
text: "list_to_check".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Lambda {
parameter_name: Name {
text: "check_with".to_string(),
unique: 0.into(),
},
}
.into(),
body: delayed_choose_list(
Term::Var(Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}),
Term::Constant(Constant::Unit),
Term::Var(
Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}
.into(),
),
Term::Constant(Constant::Unit.into()),
apply_wrap(
apply_wrap(
Term::Builtin(DefaultFunction::ChooseUnit).force_wrap(),
apply_wrap(
Term::Var(Name {
text: "check_with".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "check_with".to_string(),
unique: 0.into(),
}
.into(),
),
apply_wrap(
Term::Builtin(DefaultFunction::HeadList).force_wrap(),
Term::Var(Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
),
apply_wrap(
apply_wrap(
apply_wrap(
Term::Var(Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}),
Term::Var(Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}
.into(),
),
Term::Var(
Name {
text: ASSERT_ON_LIST.to_string(),
unique: 0.into(),
}
.into(),
),
),
apply_wrap(
Term::Builtin(DefaultFunction::TailList).force_wrap(),
Term::Var(Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "list_to_check".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
Term::Var(Name {
text: "check_with".to_string(),
unique: 0.into(),
}),
Term::Var(
Name {
text: "check_with".to_string(),
unique: 0.into(),
}
.into(),
),
),
),
)
@ -140,7 +172,8 @@ pub fn constr_fields_exposer(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: CONSTR_FIELDS_EXPOSER.to_string(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
}
.into(),
@ -148,7 +181,8 @@ pub fn constr_fields_exposer(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: "__constr_var".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Apply {
function: Term::Force(
Term::Force(Term::Builtin(DefaultFunction::SndPair).into()).into(),
@ -156,10 +190,13 @@ pub fn constr_fields_exposer(term: Term<Name>) -> Term<Name> {
.into(),
argument: Term::Apply {
function: Term::Builtin(DefaultFunction::UnConstrData).into(),
argument: Term::Var(Name {
text: "__constr_var".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__constr_var".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
@ -188,7 +225,8 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: CONSTR_GET_FIELD.to_string(),
unique: 0.into(),
},
}
.into(),
body: term.into(),
}
.into(),
@ -196,42 +234,54 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: "__constr_list".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Lambda {
parameter_name: Name {
text: "__arg_number".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Apply {
function: Term::Lambda {
parameter_name: Name {
text: "__recurse".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Apply {
function: Term::Apply {
function: Term::Apply {
function: Term::Var(Name {
text: "__recurse".to_string(),
unique: 0.into(),
})
function: Term::Var(
Name {
text: "__recurse".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
argument: Term::Var(Name {
text: "__recurse".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__recurse".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
// Start recursive with index 0 of list
argument: Term::Constant(Constant::Integer(0.into())).into(),
argument: Term::Constant(Constant::Integer(0.into()).into()).into(),
}
.into(),
argument: Term::Var(Name {
text: "__constr_list".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__constr_list".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
@ -242,17 +292,20 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: "__self_recursor".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Lambda {
parameter_name: Name {
text: "__current_arg_number".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Lambda {
parameter_name: Name {
text: "__list_of_constr_args".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Apply {
function: Term::Apply {
function: Term::Apply {
@ -268,17 +321,24 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
DefaultFunction::EqualsInteger,
)
.into(),
argument: Term::Var(Name {
text: "__arg_number".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__arg_number".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
argument: Term::Var(Name {
text: "__current_arg_number".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__current_arg_number"
.to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
@ -294,19 +354,26 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
parameter_name: Name {
text: "__current_list_of_constr_args".to_string(),
unique: 0.into(),
},
}
.into(),
body: Term::Apply {
function: Term::Apply {
function: Term::Apply {
function: Term::Var(Name {
text: "__self_recursor".to_string(),
unique: 0.into(),
})
function: Term::Var(
Name {
text: "__self_recursor".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
argument: Term::Var(Name {
text: "__self_recursor".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__self_recursor".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
@ -317,16 +384,19 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
DefaultFunction::AddInteger,
)
.into(),
argument: Term::Var(Name {
text: "__current_arg_number"
.to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__current_arg_number"
.to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
argument: Term::Constant(
Constant::Integer(1.into()),
Constant::Integer(1.into()).into(),
)
.into(),
}
@ -341,11 +411,14 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
)
.into(),
argument: Term::Var(Name {
text: "__current_list_of_constr_args"
.to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__current_list_of_constr_args"
.to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),
@ -355,10 +428,13 @@ pub fn constr_get_field(term: Term<Name>) -> Term<Name> {
.into(),
}
.into(),
argument: Term::Var(Name {
text: "__list_of_constr_args".to_string(),
unique: 0.into(),
})
argument: Term::Var(
Name {
text: "__list_of_constr_args".to_string(),
unique: 0.into(),
}
.into(),
)
.into(),
}
.into(),

75
crates/uplc/src/debruijn.rs
View File

@ -37,10 +37,13 @@ impl Converter {
term: &Term<Name>,
) -> Result<Term<NamedDeBruijn>, Error> {
let converted_term = match term {
Term::Var(name) => Term::Var(NamedDeBruijn {
text: name.text.to_string(),
index: self.get_index(name)?,
}),
Term::Var(name) => Term::Var(
NamedDeBruijn {
text: name.text.to_string(),
index: self.get_index(name)?,
}
.into(),
),
Term::Delay(term) => Term::Delay(Rc::new(self.name_to_named_debruijn(term)?)),
Term::Lambda {
parameter_name,
@ -64,7 +67,7 @@ impl Converter {
self.remove_unique(parameter_name.unique);
Term::Lambda {
parameter_name: name,
parameter_name: name.into(),
body: Rc::new(body),
}
}
@ -83,7 +86,7 @@ impl Converter {
pub fn name_to_debruijn(&mut self, term: &Term<Name>) -> Result<Term<DeBruijn>, Error> {
let converted_term = match term {
Term::Var(name) => Term::Var(self.get_index(name)?),
Term::Var(name) => Term::Var(self.get_index(name)?.into()),
Term::Delay(term) => Term::Delay(Rc::new(self.name_to_debruijn(term)?)),
Term::Lambda {
parameter_name,
@ -102,7 +105,7 @@ impl Converter {
self.remove_unique(parameter_name.unique);
Term::Lambda {
parameter_name: name,
parameter_name: name.into(),
body: Rc::new(body),
}
}
@ -124,10 +127,13 @@ impl Converter {
term: &Term<NamedDeBruijn>,
) -> Result<Term<Name>, Error> {
let converted_term = match term {
Term::Var(NamedDeBruijn { text, index }) => Term::Var(Name {
text: text.to_string(),
unique: self.get_unique(*index)?,
}),
Term::Var(var_name) => Term::Var(
Name {
text: var_name.text.to_string(),
unique: self.get_unique(&var_name.index)?,
}
.into(),
),
Term::Delay(term) => Term::Delay(Rc::new(self.named_debruijn_to_name(term)?)),
Term::Lambda {
parameter_name,
@ -135,7 +141,7 @@ impl Converter {
} => {
self.declare_binder();
let unique = self.get_unique(parameter_name.index)?;
let unique = self.get_unique(&parameter_name.index)?;
let name = Name {
text: parameter_name.text.to_string(),
@ -149,7 +155,7 @@ impl Converter {
self.end_scope();
Term::Lambda {
parameter_name: name,
parameter_name: name.into(),
body: Rc::new(body),
}
}
@ -169,12 +175,15 @@ impl Converter {
pub fn debruijn_to_name(&mut self, term: &Term<DeBruijn>) -> Result<Term<Name>, Error> {
let converted_term = match term {
Term::Var(index) => {
let unique = self.get_unique(*index)?;
let unique = self.get_unique(index)?;
Term::Var(Name {
text: format!("i_{}", unique),
unique,
})
Term::Var(
Name {
text: format!("i_{}", unique),
unique,
}
.into(),
)
}
Term::Delay(term) => Term::Delay(Rc::new(self.debruijn_to_name(term)?)),
Term::Lambda {
@ -183,7 +192,7 @@ impl Converter {
} => {
self.declare_binder();
let unique = self.get_unique(*parameter_name)?;
let unique = self.get_unique(parameter_name)?;
let name = Name {
text: format!("i_{}", unique),
@ -197,7 +206,7 @@ impl Converter {
self.end_scope();
Term::Lambda {
parameter_name: name,
parameter_name: name.into(),
body: Rc::new(body),
}
}
@ -217,13 +226,13 @@ impl Converter {
#[allow(clippy::only_used_in_recursion)]
pub fn named_debruijn_to_debruijn(&mut self, term: &Term<NamedDeBruijn>) -> Term<DeBruijn> {
match term {
Term::Var(name) => Term::Var(name.clone().into()),
Term::Var(name) => Term::Var(name.index.into()),
Term::Delay(term) => Term::Delay(Rc::new(self.named_debruijn_to_debruijn(term))),
Term::Lambda {
parameter_name,
body,
} => Term::Lambda {
parameter_name: parameter_name.clone().into(),
parameter_name: parameter_name.index.into(),
body: Rc::new(self.named_debruijn_to_debruijn(body)),
},
Term::Apply { function, argument } => Term::Apply {
@ -240,13 +249,19 @@ impl Converter {
#[allow(clippy::only_used_in_recursion)]
pub fn debruijn_to_named_debruijn(&mut self, term: &Term<DeBruijn>) -> Term<NamedDeBruijn> {
match term {
Term::Var(name) => Term::Var((*name).into()),
Term::Var(name) => Term::Var(
NamedDeBruijn {
text: format!("i_{}", name),
index: *name.as_ref(),
}
.into(),
),
Term::Delay(term) => Term::Delay(Rc::new(self.debruijn_to_named_debruijn(term))),
Term::Lambda {
parameter_name,
body,
} => Term::Lambda {
parameter_name: (*parameter_name).into(),
parameter_name: NamedDeBruijn::from(*parameter_name.as_ref()).into(),
body: Rc::new(self.debruijn_to_named_debruijn(body)),
},
Term::Apply { function, argument } => Term::Apply {
@ -266,7 +281,7 @@ impl Converter {
term: &Term<FakeNamedDeBruijn>,
) -> Term<NamedDeBruijn> {
match term {
Term::Var(name) => Term::Var(name.clone().into()),
Term::Var(name) => Term::Var(NamedDeBruijn::from(name.as_ref().clone()).into()),
Term::Delay(term) => {
Term::Delay(Rc::new(self.fake_named_debruijn_to_named_debruijn(term)))
}
@ -274,7 +289,7 @@ impl Converter {
parameter_name,
body,
} => Term::Lambda {
parameter_name: parameter_name.clone().into(),
parameter_name: NamedDeBruijn::from(parameter_name.as_ref().clone()).into(),
body: Rc::new(self.fake_named_debruijn_to_named_debruijn(body)),
},
Term::Apply { function, argument } => Term::Apply {
@ -296,7 +311,7 @@ impl Converter {
term: &Term<NamedDeBruijn>,
) -> Term<FakeNamedDeBruijn> {
match term {
Term::Var(name) => Term::Var(name.clone().into()),
Term::Var(name) => Term::Var(FakeNamedDeBruijn::from(name.as_ref().clone()).into()),
Term::Delay(term) => {
Term::Delay(Rc::new(self.named_debruijn_to_fake_named_debruijn(term)))
}
@ -304,7 +319,7 @@ impl Converter {
parameter_name,
body,
} => Term::Lambda {
parameter_name: parameter_name.clone().into(),
parameter_name: FakeNamedDeBruijn::from(parameter_name.as_ref().clone()).into(),
body: Rc::new(self.named_debruijn_to_fake_named_debruijn(body)),
},
Term::Apply { function, argument } => Term::Apply {
@ -332,7 +347,7 @@ impl Converter {
Err(Error::FreeUnique(name.clone()))
}
fn get_unique(&mut self, index: DeBruijn) -> Result<Unique, Error> {
fn get_unique(&mut self, index: &DeBruijn) -> Result<Unique, Error> {
for scope in self.levels.iter().rev() {
let index = Level(self.current_level.0 - index.inner());
@ -341,7 +356,7 @@ impl Converter {
}
}
Err(Error::FreeIndex(index))
Err(Error::FreeIndex(*index))
}
fn declare_unique(&mut self, unique: Unique) {

130
crates/uplc/src/flat.rs
View File

@ -179,10 +179,10 @@ where
{
fn decode(d: &mut Decoder) -> Result<Self, de::Error> {
match decode_term_tag(d)? {
0 => Ok(Term::Var(T::decode(d)?)),
0 => Ok(Term::Var(T::decode(d)?.into())),
1 => Ok(Term::Delay(Rc::new(Term::decode(d)?))),
2 => Ok(Term::Lambda {
parameter_name: T::binder_decode(d)?,
parameter_name: T::binder_decode(d)?.into(),
body: Rc::new(Term::decode(d)?),
}),
3 => Ok(Term::Apply {
@ -190,7 +190,7 @@ where
argument: Rc::new(Term::decode(d)?),
}),
// Need size limit for Constant
4 => Ok(Term::Constant(Constant::decode(d)?)),
4 => Ok(Term::Constant(Constant::decode(d)?.into())),
5 => Ok(Term::Force(Rc::new(Term::decode(d)?))),
6 => Ok(Term::Error),
7 => Ok(Term::Builtin(DefaultFunction::decode(d)?)),
@ -228,7 +228,7 @@ where
match var_option {
Ok(var) => {
state_log.push(format!("{})", var.text()));
Ok(Term::Var(var))
Ok(Term::Var(var.into()))
}
Err(error) => {
state_log.push("parse error)".to_string());
@ -263,7 +263,7 @@ where
Ok(term) => {
state_log.push(")".to_string());
Ok(Term::Lambda {
parameter_name: var,
parameter_name: var.into(),
body: Rc::new(term),
})
}
@ -315,7 +315,7 @@ where
match con_option {
Ok(constant) => {
state_log.push(format!("{})", constant.to_pretty()));
Ok(Term::Constant(constant))
Ok(Term::Constant(constant.into()))
}
Err(error) => {
state_log.push("parse error)".to_string());
@ -502,7 +502,7 @@ impl<'b> Decode<'b> for Constant {
let typ = decode_type(&mut rest)?;
let list: Vec<Constant> =
d.decode_list_with(|d| decode_constant_value(typ.clone(), d))?;
d.decode_list_with(|d| decode_constant_value(typ.clone().into(), d))?;
Ok(Constant::ProtoList(typ, list))
}
@ -512,10 +512,10 @@ impl<'b> Decode<'b> for Constant {
let type1 = decode_type(&mut rest)?;
let type2 = decode_type(&mut rest)?;
let a = decode_constant_value(type1.clone(), d)?;
let b = decode_constant_value(type2.clone(), d)?;
let a = decode_constant_value(type1.clone().into(), d)?;
let b = decode_constant_value(type2.clone().into(), d)?;
Ok(Constant::ProtoPair(type1, type2, Box::new(a), Box::new(b)))
Ok(Constant::ProtoPair(type1, type2, a.into(), b.into()))
}
[8] => {
let cbor = Vec::<u8>::decode(d)?;
@ -533,8 +533,8 @@ impl<'b> Decode<'b> for Constant {
}
}
fn decode_constant_value(typ: Type, d: &mut Decoder) -> Result<Constant, de::Error> {
match typ {
fn decode_constant_value(typ: Rc<Type>, d: &mut Decoder) -> Result<Constant, de::Error> {
match typ.as_ref() {
Type::Integer => Ok(Constant::Integer(i128::decode(d)?)),
Type::ByteString => Ok(Constant::ByteString(Vec::<u8>::decode(d)?)),
Type::String => Ok(Constant::String(String::decode(d)?)),
@ -542,19 +542,19 @@ fn decode_constant_value(typ: Type, d: &mut Decoder) -> Result<Constant, de::Err
Type::Bool => Ok(Constant::Bool(bool::decode(d)?)),
Type::List(sub_type) => {
let list: Vec<Constant> =
d.decode_list_with(|d| decode_constant_value(*sub_type.clone(), d))?;
d.decode_list_with(|d| decode_constant_value(sub_type.clone(), d))?;
Ok(Constant::ProtoList(*sub_type, list))
Ok(Constant::ProtoList(sub_type.as_ref().clone(), list))
}
Type::Pair(type1, type2) => {
let a = decode_constant_value(*type1.clone(), d)?;
let b = decode_constant_value(*type2.clone(), d)?;
let a = decode_constant_value(type1.clone(), d)?;
let b = decode_constant_value(type2.clone(), d)?;
Ok(Constant::ProtoPair(
*type1,
*type2,
Box::new(a),
Box::new(b),
type1.as_ref().clone(),
type2.as_ref().clone(),
a.into(),
b.into(),
))
}
Type::Data => {
@ -577,13 +577,13 @@ fn decode_type(types: &mut VecDeque<u8>) -> Result<Type, de::Error> {
Some(3) => Ok(Type::Unit),
Some(8) => Ok(Type::Data),
Some(7) => match types.pop_front() {
Some(5) => Ok(Type::List(Box::new(decode_type(types)?))),
Some(5) => Ok(Type::List(decode_type(types)?.into())),
Some(7) => match types.pop_front() {
Some(6) => {
let type1 = decode_type(types)?;
let type2 = decode_type(types)?;
Ok(Type::Pair(Box::new(type1), Box::new(type2)))
Ok(Type::Pair(type1.into(), type2.into()))
}
Some(x) => Err(de::Error::Message(format!(
"Unknown constant type tag: {}",
@ -818,7 +818,7 @@ mod test {
fn flat_encode_integer() {
let program = Program::<Name> {
version: (11, 22, 33),
term: Term::Constant(Constant::Integer(11)),
term: Term::Constant(Constant::Integer(11).into()),
};
let expected_bytes = vec![
@ -834,13 +834,16 @@ mod test {
fn flat_encode_list_list_integer() {
let program = Program::<Name> {
version: (1, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::List(Box::new(Type::Integer)),
vec![
Constant::ProtoList(Type::Integer, vec![Constant::Integer(7)]),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(5)]),
],
)),
term: Term::Constant(
Constant::ProtoList(
Type::List(Type::Integer.into()),
vec![
Constant::ProtoList(Type::Integer, vec![Constant::Integer(7)]),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(5)]),
],
)
.into(),
),
};
let expected_bytes = vec![
@ -857,17 +860,21 @@ mod test {
fn flat_encode_pair_pair_integer_bool_integer() {
let program = Program::<Name> {
version: (1, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::Pair(Box::new(Type::Integer), Box::new(Type::Bool)),
Type::Integer,
Box::new(Constant::ProtoPair(
term: Term::Constant(
Constant::ProtoPair(
Type::Pair(Type::Integer.into(), Type::Bool.into()),
Type::Integer,
Type::Bool,
Box::new(Constant::Integer(11)),
Box::new(Constant::Bool(true)),
)),
Box::new(Constant::Integer(11)),
)),
Constant::ProtoPair(
Type::Integer,
Type::Bool,
Constant::Integer(11).into(),
Constant::Bool(true).into(),
)
.into(),
Constant::Integer(11).into(),
)
.into(),
),
};
let expected_bytes = vec![
@ -889,13 +896,16 @@ mod test {
let expected_program = Program::<Name> {
version: (1, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::List(Box::new(Type::Integer)),
vec![
Constant::ProtoList(Type::Integer, vec![Constant::Integer(7)]),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(5)]),
],
)),
term: Term::Constant(
Constant::ProtoList(
Type::List(Type::Integer.into()),
vec![
Constant::ProtoList(Type::Integer, vec![Constant::Integer(7)]),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(5)]),
],
)
.into(),
),
};
let actual_program: Program<Name> = Program::unflat(&bytes).unwrap();
@ -912,17 +922,21 @@ mod test {
let expected_program = Program::<Name> {
version: (1, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::Pair(Box::new(Type::Integer), Box::new(Type::Bool)),
Type::Integer,
Box::new(Constant::ProtoPair(
term: Term::Constant(
Constant::ProtoPair(
Type::Pair(Type::Integer.into(), Type::Bool.into()),
Type::Integer,
Type::Bool,
Box::new(Constant::Integer(11)),
Box::new(Constant::Bool(true)),
)),
Box::new(Constant::Integer(11)),
)),
Constant::ProtoPair(
Type::Integer,
Type::Bool,
Constant::Integer(11).into(),
Constant::Bool(true).into(),
)
.into(),
Constant::Integer(11).into(),
)
.into(),
),
};
let actual_program: Program<Name> = Program::unflat(&bytes).unwrap();
@ -938,7 +952,7 @@ mod test {
let expected_program = Program {
version: (11, 22, 33),
term: Term::Constant(Constant::Integer(11)),
term: Term::Constant(Constant::Integer(11).into()),
};
let actual_program: Program<Name> = Program::unflat(&bytes).unwrap();

33
crates/uplc/src/machine.rs
View File

@ -39,7 +39,7 @@ enum PartialTerm {
// tag: 1
Delay,
// tag: 2
Lambda(NamedDeBruijn),
Lambda(Rc<NamedDeBruijn>),
// tag: 3
Apply,
// tag: 4
@ -330,7 +330,7 @@ impl Machine {
fn lookup_var(&mut self, name: &NamedDeBruijn, env: Rc<Vec<Value>>) -> Result<Value, Error> {
env.get::<usize>(env.len() - usize::from(name.index))
.cloned()
.ok_or_else(|| Error::OpenTermEvaluated(Term::Var(name.clone())))
.ok_or_else(|| Error::OpenTermEvaluated(Term::Var(name.clone().into())))
}
fn step_and_maybe_spend(&mut self, step: StepKind) -> Result<(), Error> {
@ -398,10 +398,7 @@ fn discharge_value(value: Value) -> Rc<Term<NamedDeBruijn>> {
0,
env,
Term::Lambda {
parameter_name: NamedDeBruijn {
text: parameter_name.text,
index: 0.into(),
},
parameter_name: parameter_name.clone(),
body,
}
.into(),
@ -511,10 +508,10 @@ enum Context {
#[derive(Clone, Debug)]
pub enum Value {
Con(Constant),
Con(Rc<Constant>),
Delay(Rc<Term<NamedDeBruijn>>, Rc<Vec<Value>>),
Lambda {
parameter_name: NamedDeBruijn,
parameter_name: Rc<NamedDeBruijn>,
body: Rc<Term<NamedDeBruijn>>,
env: Rc<Vec<Value>>,
},
@ -527,17 +524,17 @@ pub enum Value {
impl Value {
pub fn is_integer(&self) -> bool {
matches!(self, Value::Con(Constant::Integer(_)))
matches!(self, Value::Con(i) if matches!(i.as_ref(), Constant::Integer(_)))
}
pub fn is_bool(&self) -> bool {
matches!(self, Value::Con(Constant::Bool(_)))
matches!(self, Value::Con(b) if matches!(b.as_ref(), Constant::Bool(_)))
}
// TODO: Make this to_ex_mem not recursive.
pub fn to_ex_mem(&self) -> i64 {
match self {
Value::Con(c) => match c {
Value::Con(c) => match c.as_ref() {
Constant::Integer(i) => {
if *i == 0 {
1
@ -556,10 +553,10 @@ impl Value {
Constant::Unit => 1,
Constant::Bool(_) => 1,
Constant::ProtoList(_, items) => items.iter().fold(0, |acc, constant| {
acc + Value::Con(constant.clone()).to_ex_mem()
acc + Value::Con(constant.clone().into()).to_ex_mem()
}),
Constant::ProtoPair(_, _, l, r) => {
Value::Con(*l.clone()).to_ex_mem() + Value::Con(*r.clone()).to_ex_mem()
Value::Con(l.clone()).to_ex_mem() + Value::Con(r.clone()).to_ex_mem()
}
Constant::Data(item) => self.data_to_ex_mem(item),
},
@ -603,14 +600,14 @@ impl Value {
PlutusData::BigInt(i) => {
if let BigInt::Int(g) = i {
let numb: i128 = (*g).try_into().unwrap();
total += Value::Con(Constant::Integer(numb)).to_ex_mem();
total += Value::Con(Constant::Integer(numb).into()).to_ex_mem();
} else {
unreachable!()
};
}
PlutusData::BoundedBytes(b) => {
let byte_string: Vec<u8> = b.deref().clone();
total += Value::Con(Constant::ByteString(byte_string)).to_ex_mem();
total += Value::Con(Constant::ByteString(byte_string).into()).to_ex_mem();
}
PlutusData::Array(a) => {
// create new stack with of items from the list of data
@ -679,7 +676,7 @@ impl TryFrom<Value> for Constant {
fn try_from(value: Value) -> Result<Self, Self::Error> {
match value {
Value::Con(constant) => Ok(constant),
Value::Con(constant) => Ok(constant.as_ref().clone()),
rest => Err(Error::NotAConstant(rest)),
}
}
@ -693,9 +690,9 @@ impl From<&Constant> for Type {
Constant::String(_) => Type::String,
Constant::Unit => Type::Unit,
Constant::Bool(_) => Type::Bool,
Constant::ProtoList(t, _) => Type::List(Box::new(t.clone())),
Constant::ProtoList(t, _) => Type::List(Rc::new(t.clone())),
Constant::ProtoPair(t1, t2, _, _) => {
Type::Pair(Box::new(t1.clone()), Box::new(t2.clone()))
Type::Pair(Rc::new(t1.clone()), Rc::new(t2.clone()))
}
Constant::Data(_) => Type::Data,
}

837
crates/uplc/src/machine/runtime.rs
View File

File diff suppressed because it is too large Load Diff

242
crates/uplc/src/parser.rs
View File

@ -87,7 +87,7 @@ peg::parser! {
/ constant_list()
/ constant_pair()
) _* ")" {
Term::Constant(con)
Term::Constant(con.into())
}
rule builtin() -> Term<Name>
@ -96,11 +96,11 @@ peg::parser! {
}
rule var() -> Term<Name>
= n:name() { Term::Var(n) }
= n:name() { Term::Var(n.into()) }
rule lambda() -> Term<Name>
= "(" _* "lam" _+ parameter_name:name() _+ t:term() _* ")" {
Term::Lambda { parameter_name, body: Rc::new(t) }
Term::Lambda { parameter_name: parameter_name.into(), body: Rc::new(t) }
}
#[cache_left_rec]
@ -148,7 +148,7 @@ peg::parser! {
rule constant_pair() -> Constant
= "pair" _* "<" _* l:type_info() _* "," r:type_info() _* ">" _+ p:pair(Some((&l, &r))) {
Constant::ProtoPair(l, r, Box::new(p.0), Box::new(p.1))
Constant::ProtoPair(l, r, p.0.into(), p.1.into())
}
rule pair(type_info: Option<(&Type, &Type)>) -> (Constant, Constant)
@ -218,13 +218,13 @@ peg::parser! {
}
/ ls:list(list_sub_type(type_info)) {?
match type_info {
Some(Type::List(t)) => Ok(Constant::ProtoList(*t.clone(), ls)),
Some(Type::List(t)) => Ok(Constant::ProtoList(t.as_ref().clone(), ls)),
_ => Err("found 'List' instead of expected type")
}
}
/ p:pair(pair_sub_type(type_info)) {?
match type_info {
Some(Type::Pair(l, r)) => Ok(Constant::ProtoPair(*l.clone(), *r.clone(), Box::new(p.0), Box::new(p.1))),
Some(Type::Pair(l, r)) => Ok(Constant::ProtoPair(l.as_ref().clone(), r.as_ref().clone(), p.0.into(), p.1.into())),
_ => Err("found 'Pair' instead of expected type")
}
}
@ -237,10 +237,10 @@ peg::parser! {
/ _* "string" { Type::String }
/ _* "data" { Type::Data }
/ _* "list" _* "<" _* t:type_info() _* ">" {
Type::List(Box::new(t))
Type::List(t.into())
}
/ _* "pair" _* "<" l:type_info() "," r:type_info() ">" {
Type::Pair(Box::new(l), Box::new(r))
Type::Pair(l.into(), r.into())
}
rule name() -> Name
@ -274,10 +274,10 @@ mod test {
version: (1, 0, 0),
term: Term::Apply {
function: Rc::new(Term::Lambda {
parameter_name: x.clone(),
body: Rc::new(Term::Var(x)),
parameter_name: x.clone().into(),
body: Rc::new(Term::Var(x.into())),
}),
argument: Rc::new(Term::Constant(Constant::Integer(0)))
argument: Rc::new(Term::Constant(Constant::Integer(0).into()))
}
}
)
@ -295,8 +295,8 @@ mod test {
Program::<Name> {
version: (1, 0, 0),
term: Term::Lambda {
parameter_name: x.clone(),
body: Rc::new(Term::Var(x)),
parameter_name: x.clone().into(),
body: Rc::new(Term::Var(x.into())),
}
}
)
@ -314,8 +314,8 @@ mod test {
Program::<Name> {
version: (1, 0, 0),
term: Term::Lambda {
parameter_name: x.clone(),
body: Rc::new(Term::Delay(Rc::new(Term::Var(x)))),
parameter_name: x.clone().into(),
body: Rc::new(Term::Delay(Rc::new(Term::Var(x.into())))),
}
}
)
@ -344,7 +344,7 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (11, 22, 33),
term: Term::Constant(Constant::Integer(11)),
term: Term::Constant(Constant::Integer(11).into()),
}
);
}
@ -469,9 +469,13 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::AppendByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xFF]))),
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xFF]).into()
)),
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0xFF, 0x00])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0xFF, 0x00]).into()
))
}
}
)
@ -488,9 +492,9 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::ConsByteString)),
argument: Rc::new(Term::Constant(Constant::Integer(256))),
argument: Rc::new(Term::Constant(Constant::Integer(256).into())),
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![])))
argument: Rc::new(Term::Constant(Constant::ByteString(vec![]).into()))
}
}
)
@ -507,11 +511,13 @@ mod test {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::SliceByteString)),
argument: Rc::new(Term::Constant(Constant::Integer(1))),
argument: Rc::new(Term::Constant(Constant::Integer(1).into())),
}),
argument: Rc::new(Term::Constant(Constant::Integer(2))),
argument: Rc::new(Term::Constant(Constant::Integer(2).into())),
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xFF, 0xAA])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xFF, 0xAA]).into()
))
}
}
)
@ -526,7 +532,9 @@ mod test {
version: (0, 0, 0),
term: Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::LengthOfByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xFF, 0xAA])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xFF, 0xAA]).into()
))
},
}
)
@ -542,9 +550,11 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::IndexByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00])))
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00]).into()))
}),
argument: Rc::new(Term::Constant(Constant::Integer(9223372036854775808))),
argument: Rc::new(Term::Constant(
Constant::Integer(9223372036854775808).into()
)),
}
}
)
@ -560,11 +570,13 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::EqualsByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![
0x00, 0xff, 0xaa
])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xff, 0xaa]).into()
))
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xff, 0xaa]))),
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xff, 0xaa]).into()
)),
}
}
)
@ -580,9 +592,13 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::LessThanByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xff])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xff]).into()
))
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xff, 0xaa]))),
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xff, 0xaa]).into()
)),
}
}
)
@ -598,9 +614,11 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(DefaultFunction::LessThanEqualsByteString)),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xff])))
argument: Rc::new(Term::Constant(
Constant::ByteString(vec![0x00, 0xff]).into()
))
}),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00]))),
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00]).into())),
}
}
)
@ -613,7 +631,7 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![]))
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![]).into())
}
)
}
@ -625,7 +643,7 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![Constant::Unit]))
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![Constant::Unit]).into())
}
)
}
@ -637,14 +655,17 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::Bool,
vec![
Constant::Bool(true),
Constant::Bool(false),
Constant::Bool(true)
]
))
term: Term::Constant(
Constant::ProtoList(
Type::Bool,
vec![
Constant::Bool(true),
Constant::Bool(false),
Constant::Bool(true)
]
)
.into()
)
}
)
}
@ -656,13 +677,16 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::ByteString,
vec![
Constant::ByteString(vec![0x00]),
Constant::ByteString(vec![0x01]),
]
))
term: Term::Constant(
Constant::ProtoList(
Type::ByteString,
vec![
Constant::ByteString(vec![0x00]),
Constant::ByteString(vec![0x01]),
]
)
.into()
)
}
)
}
@ -674,16 +698,19 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::List(Box::new(Type::Integer)),
vec![
Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)]
),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(1337)])
]
))
term: Term::Constant(
Constant::ProtoList(
Type::List(Type::Integer.into()),
vec![
Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)]
),
Constant::ProtoList(Type::Integer, vec![Constant::Integer(1337)])
]
)
.into()
)
}
)
}
@ -703,10 +730,13 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)],
))
term: Term::Constant(
Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)],
)
.into()
)
}
)
}
@ -718,12 +748,15 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::Unit,
Type::Unit,
Box::new(Constant::Unit),
Box::new(Constant::Unit)
))
term: Term::Constant(
Constant::ProtoPair(
Type::Unit,
Type::Unit,
Constant::Unit.into(),
Constant::Unit.into()
)
.into()
)
}
)
}
@ -735,17 +768,21 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::Bool,
Type::Pair(Box::new(Type::Integer), Box::new(Type::ByteString)),
Box::new(Constant::Bool(true)),
Box::new(Constant::ProtoPair(
Type::Integer,
Type::ByteString,
Box::new(Constant::Integer(14)),
Box::new(Constant::ByteString(vec![0x42])),
))
))
term: Term::Constant(
Constant::ProtoPair(
Type::Bool,
Type::Pair(Type::Integer.into(), Type::ByteString.into()),
Constant::Bool(true).into(),
Constant::ProtoPair(
Type::Integer,
Type::ByteString,
Constant::Integer(14).into(),
Constant::ByteString(vec![0x42]).into(),
)
.into()
)
.into()
)
}
)
}
@ -757,15 +794,19 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::String,
Type::List(Box::new(Type::Integer)),
Box::new(Constant::String(String::from("foo"))),
Box::new(Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)],
))
))
term: Term::Constant(
Constant::ProtoPair(
Type::String,
Type::List(Type::Integer.into()),
Constant::String(String::from("foo")).into(),
Constant::ProtoList(
Type::Integer,
vec![Constant::Integer(14), Constant::Integer(42)],
)
.into()
)
.into()
)
}
)
}
@ -783,12 +824,15 @@ mod test {
super::program(uplc).unwrap(),
Program::<Name> {
version: (0, 0, 0),
term: Term::Constant(Constant::ProtoPair(
Type::Integer,
Type::Integer,
Box::new(Constant::Integer(14)),
Box::new(Constant::Integer(42))
))
term: Term::Constant(
Constant::ProtoPair(
Type::Integer,
Type::Integer,
Constant::Integer(14).into(),
Constant::Integer(42).into()
)
.into()
)
}
)
}
@ -815,9 +859,9 @@ mod test {
term: Term::Apply {
function: Rc::new(Term::Apply {
function: Rc::new(Term::Builtin(default_function)),
argument: Rc::new(Term::Constant(Constant::Integer(x))),
argument: Rc::new(Term::Constant(Constant::Integer(x).into())),
}),
argument: Rc::new(Term::Constant(Constant::Integer(y)))
argument: Rc::new(Term::Constant(Constant::Integer(y).into()))
}
}
)

6
crates/uplc/src/parser/interner.rs
View File

@ -27,12 +27,16 @@ impl Interner {
pub fn term(&mut self, term: &mut Term<Name>) {
match term {
Term::Var(name) => name.unique = self.intern(&name.text),
Term::Var(name) => {
let name = Rc::make_mut(name);
name.unique = self.intern(&name.text)
}
Term::Delay(term) => self.term(Rc::make_mut(term)),
Term::Lambda {
parameter_name,
body,
} => {
let parameter_name = Rc::make_mut(parameter_name);
parameter_name.unique = self.intern(&parameter_name.text);
self.term(Rc::make_mut(body));
}

10
crates/uplc/src/program_builder/constant.rs
View File

@ -3,27 +3,27 @@ use crate::program_builder::WithTerm;
pub trait WithConstant: WithTerm {
fn with_int(self, int: i128) -> Self::Next {
let term = Term::Constant(Constant::Integer(int));
let term = Term::Constant(Constant::Integer(int).into());
self.next(term)
}
fn with_byte_string(self, bytes: Vec<u8>) -> Self::Next {
let term = Term::Constant(Constant::ByteString(bytes));
let term = Term::Constant(Constant::ByteString(bytes).into());
self.next(term)
}
fn with_string(self, string: String) -> Self::Next {
let term = Term::Constant(Constant::String(string));
let term = Term::Constant(Constant::String(string).into());
self.next(term)
}
fn with_unit(self) -> Self::Next {
let term = Term::Constant(Constant::Unit);
let term = Term::Constant(Constant::Unit.into());
self.next(term)
}
fn with_bool(self, bool: bool) -> Self::Next {
let term = Term::Constant(Constant::Bool(bool));
let term = Term::Constant(Constant::Bool(bool).into());
self.next(term)
}
}

2
crates/uplc/src/program_builder/lambda.rs
View File

@ -13,7 +13,7 @@ impl<T: WithTerm> WithTerm for LambdaBuilder<T> {
fn next(self, term: Term<Name>) -> Self::Next {
let term = Term::Lambda {
parameter_name: self.parameter_name,
parameter_name: self.parameter_name.into(),
body: Rc::new(term),
};
self.outer.next(term)

2
crates/uplc/src/program_builder/var.rs
View File

@ -4,7 +4,7 @@ use crate::program_builder::WithTerm;
pub trait WithVar: WithTerm {
fn with_var(self, name_str: &str) -> Self::Next {
let name = self.get_name(name_str);
let term = Term::Var(name);
let term = Term::Var(name.into());
self.next(term)
}
}

2
crates/uplc/test_data/fibonacci/fibonacci.uplc
View File

@ -84,6 +84,6 @@
i_0
]
)
(con integer 15)
(con integer 0)
]
)