826 lines
26 KiB
Rust
826 lines
26 KiB
Rust
use std::{rc::Rc, str::FromStr};
|
|
|
|
use crate::{
|
|
ast::{Constant, Name, Program, Term, Type},
|
|
builtins::DefaultFunction,
|
|
};
|
|
|
|
use interner::Interner;
|
|
use pallas_primitives::{alonzo::PlutusData, Fragment};
|
|
use peg::{error::ParseError, str::LineCol};
|
|
|
|
pub mod interner;
|
|
|
|
/// Parse a `Program` from a str.
|
|
pub fn program(src: &str) -> Result<Program<Name>, ParseError<LineCol>> {
|
|
// initialize the string interner to get unique name
|
|
let mut interner = Interner::new();
|
|
|
|
// run the generated parser
|
|
let mut program = uplc::program(src)?;
|
|
|
|
// assign proper unique ids in place
|
|
interner.program(&mut program);
|
|
|
|
Ok(program)
|
|
}
|
|
|
|
pub fn term(src: &str) -> Result<Term<Name>, ParseError<LineCol>> {
|
|
// initialize the string interner to get unique name
|
|
let mut interner = Interner::new();
|
|
|
|
// run the generated parser
|
|
let mut term = uplc::term(src)?;
|
|
|
|
// assign proper unique ids in place
|
|
interner.term(&mut term);
|
|
|
|
Ok(term)
|
|
}
|
|
|
|
// Returns the inner type of a list, provided that the given type is a list.
|
|
fn list_sub_type(type_info: Option<&Type>) -> Option<&Type> {
|
|
match type_info {
|
|
Some(Type::List(t)) => Some(t),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
// Returns the left and right types of a pair, provided that the given type is a pair.
|
|
fn pair_sub_type(type_info: Option<&Type>) -> Option<(&Type, &Type)> {
|
|
match type_info {
|
|
Some(Type::Pair(l, r)) => Some((l, r)),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
peg::parser! {
|
|
grammar uplc() for str {
|
|
pub rule program() -> Program<Name>
|
|
= _* "(" _* "program" _+ v:version() _+ t:term() _* ")" _* {
|
|
Program {version: v, term: t}
|
|
}
|
|
|
|
rule version() -> (usize, usize, usize)
|
|
= major:number() "." minor:number() "." patch:number() {
|
|
(major as usize, minor as usize, patch as usize)
|
|
}
|
|
|
|
pub rule term() -> Term<Name>
|
|
= constant()
|
|
/ builtin()
|
|
/ var()
|
|
/ lambda()
|
|
/ apply()
|
|
/ delay()
|
|
/ force()
|
|
/ error()
|
|
|
|
rule constant() -> Term<Name>
|
|
= "(" _* "con" _+ con:(
|
|
constant_integer()
|
|
/ constant_bytestring()
|
|
/ constant_string()
|
|
/ constant_unit()
|
|
/ constant_bool()
|
|
/ constant_data()
|
|
/ constant_list()
|
|
/ constant_pair()
|
|
) _* ")" {
|
|
Term::Constant(con)
|
|
}
|
|
|
|
rule builtin() -> Term<Name>
|
|
= "(" _* "builtin" _+ b:ident() _* ")" {
|
|
Term::Builtin(DefaultFunction::from_str(&b).unwrap())
|
|
}
|
|
|
|
rule var() -> Term<Name>
|
|
= n:name() { Term::Var(n) }
|
|
|
|
rule lambda() -> Term<Name>
|
|
= "(" _* "lam" _+ parameter_name:name() _+ t:term() _* ")" {
|
|
Term::Lambda { parameter_name, body: Rc::new(t) }
|
|
}
|
|
|
|
#[cache_left_rec]
|
|
rule apply() -> Term<Name>
|
|
= "[" _* initial:term() _+ terms:(t:term() _* { t })+ "]" {
|
|
terms
|
|
.into_iter()
|
|
.fold(initial, |lhs, rhs| Term::Apply {
|
|
function: Rc::new(lhs),
|
|
argument: Rc::new(rhs)
|
|
})
|
|
}
|
|
|
|
rule delay() -> Term<Name>
|
|
= "(" _* "delay" _* t:term() _* ")" { Term::Delay(Rc::new(t)) }
|
|
|
|
rule force() -> Term<Name>
|
|
= "(" _* "force" _* t:term() _* ")" { Term::Force(Rc::new(t)) }
|
|
|
|
rule error() -> Term<Name>
|
|
= "(" _* "error" _* ")" { Term::Error }
|
|
|
|
rule constant_integer() -> Constant
|
|
= "integer" _+ i:big_number() { Constant::Integer(i) }
|
|
|
|
rule constant_bytestring() -> Constant
|
|
= "bytestring" _+ bs:bytestring() { Constant::ByteString(bs) }
|
|
|
|
rule constant_string() -> Constant
|
|
= "string" _+ s:string() { Constant::String(s) }
|
|
|
|
rule constant_bool() -> Constant
|
|
= "bool" _+ b:boolean() { Constant::Bool(b) }
|
|
|
|
rule constant_unit() -> Constant
|
|
= "unit" _+ "()" { Constant::Unit }
|
|
|
|
rule constant_data() -> Constant
|
|
= "data" _+ d:data() { Constant::Data(d) }
|
|
|
|
rule constant_list() -> Constant
|
|
= "list" _* "<" _* t:type_info() _* ">" _+ ls:list(Some(&t)) {
|
|
Constant::ProtoList(t, ls)
|
|
}
|
|
|
|
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))
|
|
}
|
|
|
|
rule pair(type_info: Option<(&Type, &Type)>) -> (Constant, Constant)
|
|
= "[" _* x:typed_constant(type_info.map(|t| t.0)) _* "," _* y:typed_constant(type_info.map(|t| t.1)) _* "]" { (x, y) }
|
|
|
|
rule number() -> isize
|
|
= n:$("-"* ['0'..='9']+) {? n.parse().or(Err("isize")) }
|
|
|
|
rule big_number() -> i128
|
|
= n:$("-"* ['0'..='9']+) {? n.parse().or(Err("i128")) }
|
|
|
|
rule boolean() -> bool
|
|
= b:$("True" / "False") { b == "True" }
|
|
|
|
rule bytestring() -> Vec<u8>
|
|
= "#" i:ident()* { hex::decode(String::from_iter(i)).unwrap() }
|
|
|
|
rule string() -> String
|
|
= "\"" s:[^ '"']* "\"" { String::from_iter(s) }
|
|
|
|
rule data() -> PlutusData
|
|
= "#" i:ident()* {
|
|
PlutusData::decode_fragment(
|
|
hex::decode(String::from_iter(i)).unwrap().as_slice()
|
|
).unwrap()
|
|
}
|
|
|
|
rule list(type_info: Option<&Type>) -> Vec<Constant>
|
|
= "[" _* xs:(typed_constant(type_info) ** (_* "," _*)) _* "]" { xs }
|
|
|
|
rule typed_constant(type_info : Option<&Type>) -> Constant
|
|
= "()" {?
|
|
match type_info {
|
|
Some(Type::Unit) => Ok(Constant::Unit),
|
|
_ => Err("found 'Unit' instead of expected type")
|
|
}
|
|
}
|
|
/ b:boolean() {?
|
|
match type_info {
|
|
Some(Type::Bool) => Ok(Constant::Bool(b)),
|
|
_ => Err("found 'Bool' instead of expected type")
|
|
}
|
|
}
|
|
/ n:big_number() {?
|
|
match type_info {
|
|
Some(Type::Integer) => Ok(Constant::Integer(n)),
|
|
_ => Err("found 'Integer' instead of expected type")
|
|
}
|
|
}
|
|
/ bs:bytestring() {?
|
|
match type_info {
|
|
Some(Type::ByteString) => Ok(Constant::ByteString(bs)),
|
|
_ => Err("found 'ByteString' instead of expected type")
|
|
}
|
|
}
|
|
/ s:string() {?
|
|
match type_info {
|
|
Some(Type::String) => Ok(Constant::String(s)),
|
|
_ => Err("found 'String' instead of expected type")
|
|
}
|
|
}
|
|
/ s:data() {?
|
|
match type_info {
|
|
Some(Type::Data) => Ok(Constant::Data(s)),
|
|
_ => Err("found 'Data' instead of expected type")
|
|
}
|
|
}
|
|
/ ls:list(list_sub_type(type_info)) {?
|
|
match type_info {
|
|
Some(Type::List(t)) => Ok(Constant::ProtoList(*t.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))),
|
|
_ => Err("found 'Pair' instead of expected type")
|
|
}
|
|
}
|
|
|
|
rule type_info() -> Type
|
|
= _* "unit" { Type::Unit }
|
|
/ _* "bool" { Type::Bool }
|
|
/ _* "integer" { Type::Integer }
|
|
/ _* "bytestring" { Type::ByteString }
|
|
/ _* "string" { Type::String }
|
|
/ _* "data" { Type::Data }
|
|
/ _* "list" _* "<" _* t:type_info() _* ">" {
|
|
Type::List(Box::new(t))
|
|
}
|
|
/ _* "pair" _* "<" l:type_info() "," r:type_info() ">" {
|
|
Type::Pair(Box::new(l), Box::new(r))
|
|
}
|
|
|
|
rule name() -> Name
|
|
= text:ident() { Name { text, unique: 0.into() } }
|
|
|
|
rule ident() -> String
|
|
= i:['a'..='z' | 'A'..='Z' | '0'..='9' | '_']+ {
|
|
String::from_iter(i)
|
|
}
|
|
|
|
rule _ = [' ' | '\n']
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::ast::{Constant, Name, Program, Term, Type, Unique};
|
|
use crate::builtins::DefaultFunction;
|
|
use std::rc::Rc;
|
|
|
|
#[test]
|
|
fn parse_apply() {
|
|
let uplc = "(program 1.0.0 [(lam x x) (con integer 0)])";
|
|
let x = Name {
|
|
text: "x".to_string(),
|
|
unique: Unique::new(0),
|
|
};
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
term: Term::Apply {
|
|
function: Rc::new(Term::Lambda {
|
|
parameter_name: x.clone(),
|
|
body: Rc::new(Term::Var(x)),
|
|
}),
|
|
argument: Rc::new(Term::Constant(Constant::Integer(0)))
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_lambda() {
|
|
let uplc = "(program 1.0.0 (lam x x))";
|
|
let x = Name {
|
|
text: "x".to_string(),
|
|
unique: Unique::new(0),
|
|
};
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
term: Term::Lambda {
|
|
parameter_name: x.clone(),
|
|
body: Rc::new(Term::Var(x)),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_delay_lambda() {
|
|
let uplc = "(program 1.0.0 (lam x (delay x)))";
|
|
let x = Name {
|
|
text: "x".to_string(),
|
|
unique: Unique::new(0),
|
|
};
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
term: Term::Lambda {
|
|
parameter_name: x.clone(),
|
|
body: Rc::new(Term::Delay(Rc::new(Term::Var(x)))),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_error() {
|
|
let uplc = "(program 1.0.0 (error))";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
term: Term::Error
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_formatted() {
|
|
let uplc = r#"
|
|
(program 11.22.33
|
|
(con integer 11)
|
|
)
|
|
"#;
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (11, 22, 33),
|
|
term: Term::Constant(Constant::Integer(11)),
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_add_integer_curried() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ [ (builtin addInteger) (con integer 1)] (con integer 1) ])",
|
|
DefaultFunction::AddInteger,
|
|
1,
|
|
1,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_add_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin addInteger) (con integer 1) (con integer 2) ])",
|
|
DefaultFunction::AddInteger,
|
|
1,
|
|
2,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_subtract_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin subtractInteger) (con integer 42) (con integer 14) ])",
|
|
DefaultFunction::SubtractInteger,
|
|
42,
|
|
14,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_multiply_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin multiplyInteger) (con integer 1) (con integer -1) ])",
|
|
DefaultFunction::MultiplyInteger,
|
|
1,
|
|
-1,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_divide_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin divideInteger) (con integer 1) (con integer 0) ])",
|
|
DefaultFunction::DivideInteger,
|
|
1,
|
|
0,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_quotient_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin quotientInteger) (con integer 1) (con integer 0) ])",
|
|
DefaultFunction::QuotientInteger,
|
|
1,
|
|
0,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_remainder_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ (builtin remainderInteger) (con integer 1) (con integer 0) ])",
|
|
DefaultFunction::RemainderInteger,
|
|
1,
|
|
0,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_mod_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ [ (builtin modInteger) (con integer 2) ] (con integer 3) ])",
|
|
DefaultFunction::ModInteger,
|
|
2,
|
|
3,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_equals_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ [ (builtin equalsInteger) (con integer 1) ] (con integer 2) ])",
|
|
DefaultFunction::EqualsInteger,
|
|
1,
|
|
2,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_less_than_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ [ (builtin lessThanInteger) (con integer 1) ] (con integer 2) ])",
|
|
DefaultFunction::LessThanInteger,
|
|
1,
|
|
2,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_less_than_equals_integer() {
|
|
parse_builtin_integer(
|
|
"(program 1.0.0 [ [ (builtin lessThanEqualsInteger) (con integer 1) ] (con integer 2) ])",
|
|
DefaultFunction::LessThanEqualsInteger,
|
|
1,
|
|
2,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_append_bytestring() {
|
|
let uplc = "(program 1.0.0 [ [(builtin appendByteString) (con bytestring #00FF)] (con bytestring #FF00) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
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![0xFF, 0x00])))
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_cons_bytestring() {
|
|
let uplc =
|
|
"(program 1.0.0 [(builtin consByteString) (con integer 256) (con bytestring #)])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
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::ByteString(vec![])))
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_slice_bytestring() {
|
|
let uplc = "(program 0.0.0 [ [ [ (builtin sliceByteString) (con integer 1)] (con integer 2) ] (con bytestring #00ffaa) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
term: Term::Apply {
|
|
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(2))),
|
|
}),
|
|
argument: Rc::new(Term::Constant(Constant::ByteString(vec![0x00, 0xFF, 0xAA])))
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_length_of_bytestring() {
|
|
let uplc = "(program 0.0.0 [ (builtin lengthOfByteString) (con bytestring #00ffaa) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
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])))
|
|
},
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_index_bytestring() {
|
|
let uplc = "(program 1.0.0 [(builtin indexByteString) (con bytestring #00) (con integer 9223372036854775808)])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
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::Integer(9223372036854775808))),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_equals_bytestring() {
|
|
let uplc = "(program 0.0.0 [ [ (builtin equalsByteString) (con bytestring #00ffaa) ] (con bytestring #00ffaa) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
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]))),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_less_than_bytestring() {
|
|
let uplc = "(program 0.0.0 [ [(builtin lessThanByteString) (con bytestring #00ff)] (con bytestring #00ffaa) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
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, 0xaa]))),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_builtin_less_than_equals_bytestring() {
|
|
let uplc = "(program 0.0.0 [ [(builtin lessThanEqualsByteString) (con bytestring #00ff)] (con bytestring #00) ])";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
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]))),
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_empty() {
|
|
let uplc = "(program 0.0.0 (con list<unit> []))";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![]))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_singleton_unit() {
|
|
let uplc = "(program 0.0.0 (con list<unit> [ () ]))";
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
term: Term::Constant(Constant::ProtoList(Type::Unit, vec![Constant::Unit]))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_bools() {
|
|
let uplc = "(program 0.0.0 (con list<bool> [True, False, True]))";
|
|
assert_eq!(
|
|
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)
|
|
]
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_bytestrings() {
|
|
let uplc = "(program 0.0.0 (con list<bytestring> [#00, #01]))";
|
|
assert_eq!(
|
|
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]),
|
|
]
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_list_integers() {
|
|
let uplc = "(program 0.0.0 (con list<list<integer>> [[14,42], [1337]]))";
|
|
assert_eq!(
|
|
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)])
|
|
]
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_multiline() {
|
|
let uplc = r#"
|
|
(program 0.0.0
|
|
(con list
|
|
<integer>
|
|
[ 14
|
|
, 42
|
|
]
|
|
)
|
|
)"#;
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (0, 0, 0),
|
|
term: Term::Constant(Constant::ProtoList(
|
|
Type::Integer,
|
|
vec![Constant::Integer(14), Constant::Integer(42)],
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_pair_unit_unit() {
|
|
let uplc = "(program 0.0.0 (con pair <unit,unit> [(),()]))";
|
|
assert_eq!(
|
|
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)
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_pair_bool_pair_integer_bytestring() {
|
|
let uplc = "(program 0.0.0 (con pair<bool, pair<integer, bytestring>> [True, [14, #42]]))";
|
|
assert_eq!(
|
|
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])),
|
|
))
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_pair_string_list_integer() {
|
|
let uplc = "(program 0.0.0 (con pair<string, list<integer>> [\"foo\", [14, 42]]))";
|
|
assert_eq!(
|
|
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)],
|
|
))
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_pair_multiline() {
|
|
let uplc = r#"
|
|
(program 0.0.0
|
|
(con pair
|
|
<integer, integer>
|
|
[14, 42]
|
|
)
|
|
)"#;
|
|
assert_eq!(
|
|
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))
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_type_mismatch() {
|
|
let uplc = "(program 0.0.0 (con list<integer> [True, False]))";
|
|
assert!(super::program(uplc).is_err())
|
|
}
|
|
|
|
#[test]
|
|
fn parse_list_mixed_types() {
|
|
let uplc = "(program 0.0.0 (con list<integer> [14, False]))";
|
|
assert!(super::program(uplc).is_err())
|
|
}
|
|
|
|
// Helper function for all simple programs that involve only a direct application of a builtin
|
|
// function operating on two integers.
|
|
fn parse_builtin_integer(uplc: &str, default_function: DefaultFunction, x: i128, y: i128) {
|
|
assert_eq!(
|
|
super::program(uplc).unwrap(),
|
|
Program::<Name> {
|
|
version: (1, 0, 0),
|
|
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(y)))
|
|
}
|
|
}
|
|
)
|
|
}
|
|
}
|