mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-29 06:44:46 +00:00
1969 lines
48 KiB
Rust
1969 lines
48 KiB
Rust
#[macro_use]
|
|
extern crate pretty_assertions;
|
|
#[macro_use]
|
|
extern crate indoc;
|
|
|
|
extern crate bumpalo;
|
|
extern crate inkwell;
|
|
extern crate libc;
|
|
extern crate roc_gen;
|
|
|
|
mod helpers;
|
|
|
|
#[cfg(test)]
|
|
mod test_gen {
|
|
use crate::helpers::{can_expr, infer_expr, uniq_expr, CanExprOut};
|
|
use bumpalo::Bump;
|
|
use cranelift::prelude::{AbiParam, ExternalName, FunctionBuilder, FunctionBuilderContext};
|
|
use cranelift_codegen::ir::InstBuilder;
|
|
use cranelift_codegen::settings;
|
|
use cranelift_codegen::verifier::verify_function;
|
|
use cranelift_module::{default_libcall_names, Linkage, Module};
|
|
use cranelift_simplejit::{SimpleJITBackend, SimpleJITBuilder};
|
|
use inkwell::context::Context;
|
|
use inkwell::execution_engine::JitFunction;
|
|
use inkwell::passes::PassManager;
|
|
use inkwell::types::BasicType;
|
|
use inkwell::OptimizationLevel;
|
|
use roc_collections::all::ImMap;
|
|
use roc_gen::crane::build::{declare_proc, define_proc_body, ScopeEntry};
|
|
use roc_gen::crane::convert::type_from_layout;
|
|
use roc_gen::crane::imports::define_malloc;
|
|
use roc_gen::llvm::build::{build_proc, build_proc_header};
|
|
use roc_gen::llvm::convert::basic_type_from_layout;
|
|
use roc_mono::expr::{Expr, Procs};
|
|
use roc_mono::layout::Layout;
|
|
use roc_types::subs::Subs;
|
|
use std::ffi::{CStr, CString};
|
|
use std::mem;
|
|
use std::os::raw::c_char;
|
|
|
|
// Pointer size on 64-bit platforms
|
|
const POINTER_SIZE: u32 = std::mem::size_of::<u64>() as u32;
|
|
|
|
macro_rules! assert_crane_evals_to {
|
|
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
|
|
let arena = Bump::new();
|
|
let CanExprOut { loc_expr, var_store, var, constraint, home, interns, .. } = can_expr($src);
|
|
let subs = Subs::new(var_store.into());
|
|
let mut unify_problems = Vec::new();
|
|
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
|
|
let shared_builder = settings::builder();
|
|
let shared_flags = settings::Flags::new(shared_builder);
|
|
let mut module: Module<SimpleJITBackend> =
|
|
Module::new(SimpleJITBuilder::new(default_libcall_names()));
|
|
|
|
let cfg = module.target_config();
|
|
let mut ctx = module.make_context();
|
|
let malloc = define_malloc(&mut module, &mut ctx);
|
|
let mut func_ctx = FunctionBuilderContext::new();
|
|
|
|
let main_fn_name = "$Test.main";
|
|
|
|
// Compute main_fn_ret_type before moving subs to Env
|
|
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
|
|
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert content to layout. Err was {:?} and Subs were {:?}", err, subs));
|
|
let main_ret_type = type_from_layout(cfg, &layout);
|
|
|
|
// Compile and add all the Procs before adding main
|
|
let mut procs = Procs::default();
|
|
let mut env = roc_gen::crane::build::Env {
|
|
arena: &arena,
|
|
interns,
|
|
cfg,
|
|
malloc,
|
|
variable_counter: &mut 0
|
|
|
|
};
|
|
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
|
|
|
|
// Populate Procs and Subs, and get the low-level Expr from the canonical Expr
|
|
let mono_expr = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
|
|
|
|
// Put this module's ident_ids back in the interns
|
|
env.interns.all_ident_ids.insert(home, ident_ids);
|
|
|
|
let mut scope = ImMap::default();
|
|
let mut declared = Vec::with_capacity(procs.len());
|
|
|
|
// Declare all the Procs, then insert them into scope so their bodies
|
|
// can look up their Funcs in scope later when calling each other by value.
|
|
for (name, opt_proc) in procs.as_map().into_iter() {
|
|
if let Some(proc) = opt_proc {
|
|
let (func_id, sig) = declare_proc(&mut env, &mut module, name, &proc);
|
|
|
|
declared.push((proc.clone(), sig.clone(), func_id));
|
|
|
|
scope.insert(name.clone(), ScopeEntry::Func { func_id, sig });
|
|
}
|
|
}
|
|
|
|
for (proc, sig, fn_id) in declared {
|
|
define_proc_body(
|
|
&mut env,
|
|
&mut ctx,
|
|
&mut module,
|
|
fn_id,
|
|
&scope,
|
|
sig,
|
|
arena.alloc(proc),
|
|
&procs,
|
|
);
|
|
|
|
// Verify the function we just defined
|
|
if let Err(errors) = verify_function(&ctx.func, &shared_flags) {
|
|
// NOTE: We don't include proc here because it's already
|
|
// been moved. If you need to know which proc failed, go back
|
|
// and add some logging.
|
|
panic!("Errors defining proc: {}", errors);
|
|
}
|
|
}
|
|
|
|
// Add main itself
|
|
let mut sig = module.make_signature();
|
|
sig.returns.push(AbiParam::new(main_ret_type));
|
|
|
|
let main_fn = module
|
|
.declare_function(main_fn_name, Linkage::Local, &sig)
|
|
.unwrap();
|
|
|
|
ctx.func.signature = sig;
|
|
ctx.func.name = ExternalName::user(0, main_fn.as_u32());
|
|
|
|
{
|
|
let mut builder: FunctionBuilder =
|
|
FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
|
|
let block = builder.create_block();
|
|
|
|
builder.switch_to_block(block);
|
|
// TODO try deleting this line and seeing if everything still works.
|
|
builder.append_block_params_for_function_params(block);
|
|
|
|
let main_body =
|
|
roc_gen::crane::build::build_expr(&mut env, &scope, &mut module, &mut builder, &mono_expr, &procs);
|
|
|
|
builder.ins().return_(&[main_body]);
|
|
// TODO re-enable this once Switch stops making unsealed blocks, e.g.
|
|
// https://docs.rs/cranelift-frontend/0.59.0/src/cranelift_frontend/switch.rs.html#152
|
|
// builder.seal_block(block);
|
|
builder.seal_all_blocks();
|
|
builder.finalize();
|
|
}
|
|
|
|
module.define_function(main_fn, &mut ctx).expect("crane declare main");
|
|
module.clear_context(&mut ctx);
|
|
|
|
// Perform linking
|
|
module.finalize_definitions();
|
|
|
|
// Verify the main function
|
|
if let Err(errors) = verify_function(&ctx.func, &shared_flags) {
|
|
panic!("Errors defining {} - {}", main_fn_name, errors);
|
|
}
|
|
|
|
let main_ptr = module.get_finalized_function(main_fn);
|
|
|
|
unsafe {
|
|
let run_main = mem::transmute::<_, fn() -> $ty>(main_ptr) ;
|
|
|
|
assert_eq!($transform(run_main()), $expected);
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! assert_llvm_evals_to {
|
|
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
|
|
let arena = Bump::new();
|
|
let CanExprOut { loc_expr, var_store, var, constraint, home, interns, .. } = can_expr($src);
|
|
let subs = Subs::new(var_store.into());
|
|
let mut unify_problems = Vec::new();
|
|
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
|
|
|
|
let context = Context::create();
|
|
let module = context.create_module("app");
|
|
let builder = context.create_builder();
|
|
let fpm = PassManager::create(&module);
|
|
|
|
// Enable optimizations when running cargo test --release
|
|
if !cfg!(debug_assertions) {
|
|
fpm.add_instruction_combining_pass();
|
|
fpm.add_reassociate_pass();
|
|
fpm.add_basic_alias_analysis_pass();
|
|
fpm.add_promote_memory_to_register_pass();
|
|
fpm.add_cfg_simplification_pass();
|
|
fpm.add_gvn_pass();
|
|
// TODO figure out why enabling any of these (even alone) causes LLVM to segfault
|
|
// fpm.add_strip_dead_prototypes_pass();
|
|
// fpm.add_dead_arg_elimination_pass();
|
|
// fpm.add_function_inlining_pass();
|
|
}
|
|
|
|
fpm.initialize();
|
|
|
|
// Compute main_fn_type before moving subs to Env
|
|
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
|
|
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
|
|
let execution_engine =
|
|
module
|
|
.create_jit_execution_engine(OptimizationLevel::None)
|
|
.expect("Error creating JIT execution engine for test");
|
|
|
|
let ptr_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
|
|
|
|
let main_fn_type = basic_type_from_layout(&arena, &context, &layout, ptr_bytes)
|
|
.fn_type(&[], false);
|
|
let main_fn_name = "$Test.main";
|
|
|
|
// Compile and add all the Procs before adding main
|
|
let mut env = roc_gen::llvm::build::Env {
|
|
arena: &arena,
|
|
builder: &builder,
|
|
context: &context,
|
|
interns,
|
|
module: arena.alloc(module),
|
|
ptr_bytes
|
|
};
|
|
let mut procs = Procs::default();
|
|
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
|
|
|
|
// Populate Procs and get the low-level Expr from the canonical Expr
|
|
let main_body = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
|
|
|
|
// Put this module's ident_ids back in the interns, so we can use them in Env.
|
|
env.interns.all_ident_ids.insert(home, ident_ids);
|
|
|
|
let mut headers = Vec::with_capacity(procs.len());
|
|
|
|
// Add all the Proc headers to the module.
|
|
// We have to do this in a separate pass first,
|
|
// because their bodies may reference each other.
|
|
for (symbol, opt_proc) in procs.as_map().into_iter() {
|
|
if let Some(proc) = opt_proc {
|
|
let (fn_val, arg_basic_types) = build_proc_header(&env, symbol, &proc);
|
|
|
|
headers.push((proc, fn_val, arg_basic_types));
|
|
}
|
|
}
|
|
|
|
// Build each proc using its header info.
|
|
for (proc, fn_val, arg_basic_types) in headers {
|
|
// NOTE: This is here to be uncommented in case verification fails.
|
|
// (This approach means we don't have to defensively clone name here.)
|
|
//
|
|
// println!("\n\nBuilding and then verifying function {}\n\n", name);
|
|
build_proc(&env, proc, &procs, fn_val, arg_basic_types);
|
|
|
|
if fn_val.verify(true) {
|
|
fpm.run_on(&fn_val);
|
|
} else {
|
|
// NOTE: If this fails, uncomment the above println to debug.
|
|
panic!("Non-main function failed LLVM verification. Uncomment the above println to debug!");
|
|
}
|
|
}
|
|
|
|
// Add main to the module.
|
|
let main_fn = env.module.add_function(main_fn_name, main_fn_type, None);
|
|
|
|
// Add main's body
|
|
let basic_block = context.append_basic_block(main_fn, "entry");
|
|
|
|
builder.position_at_end(basic_block);
|
|
|
|
let ret = roc_gen::llvm::build::build_expr(
|
|
&env,
|
|
&ImMap::default(),
|
|
main_fn,
|
|
&main_body,
|
|
&mut Procs::default(),
|
|
);
|
|
|
|
builder.build_return(Some(&ret));
|
|
|
|
// Uncomment this to see the module's un-optimized LLVM instruction output:
|
|
// env.module.print_to_stderr();
|
|
|
|
if main_fn.verify(true) {
|
|
fpm.run_on(&main_fn);
|
|
} else {
|
|
panic!("Function {} failed LLVM verification.", main_fn_name);
|
|
}
|
|
|
|
// Verify the module
|
|
if let Err(errors) = env.module.verify() {
|
|
panic!("Errors defining module: {:?}", errors);
|
|
}
|
|
|
|
// Uncomment this to see the module's optimized LLVM instruction output:
|
|
// env.module.print_to_stderr();
|
|
|
|
unsafe {
|
|
let main: JitFunction<unsafe extern "C" fn() -> $ty> = execution_engine
|
|
.get_function(main_fn_name)
|
|
.ok()
|
|
.ok_or(format!("Unable to JIT compile `{}`", main_fn_name))
|
|
.expect("errored");
|
|
|
|
assert_eq!($transform(main.call()), $expected);
|
|
}
|
|
};
|
|
}
|
|
|
|
// TODO this is almost all code duplication with the one in test_gen;
|
|
// the only difference is that this calls uniq_expr instead of can_expr.
|
|
// Should extract the common logic into test helpers.
|
|
macro_rules! assert_opt_evals_to {
|
|
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
|
|
let arena = Bump::new();
|
|
let (loc_expr, _output, _problems, subs, var, constraint, home, interns) = uniq_expr($src);
|
|
|
|
let mut unify_problems = Vec::new();
|
|
let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
|
|
|
|
let context = Context::create();
|
|
let module = context.create_module("app");
|
|
let builder = context.create_builder();
|
|
let fpm = PassManager::create(&module);
|
|
|
|
// Enable optimizations when running cargo test --release
|
|
if !cfg!(debug_assertions) {
|
|
fpm.add_instruction_combining_pass();
|
|
fpm.add_reassociate_pass();
|
|
fpm.add_basic_alias_analysis_pass();
|
|
fpm.add_promote_memory_to_register_pass();
|
|
fpm.add_cfg_simplification_pass();
|
|
fpm.add_gvn_pass();
|
|
// TODO figure out why enabling any of these (even alone) causes LLVM to segfault
|
|
// fpm.add_strip_dead_prototypes_pass();
|
|
// fpm.add_dead_arg_elimination_pass();
|
|
// fpm.add_function_inlining_pass();
|
|
}
|
|
|
|
fpm.initialize();
|
|
|
|
// Compute main_fn_type before moving subs to Env
|
|
let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
|
|
.unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
|
|
|
|
let execution_engine =
|
|
module
|
|
.create_jit_execution_engine(OptimizationLevel::None)
|
|
.expect("Error creating JIT execution engine for test");
|
|
|
|
let ptr_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
|
|
let main_fn_type = basic_type_from_layout(&arena, &context, &layout, ptr_bytes)
|
|
.fn_type(&[], false);
|
|
let main_fn_name = "$Test.main";
|
|
|
|
// Compile and add all the Procs before adding main
|
|
let mut env = roc_gen::llvm::build::Env {
|
|
arena: &arena,
|
|
builder: &builder,
|
|
context: &context,
|
|
interns,
|
|
module: arena.alloc(module),
|
|
ptr_bytes
|
|
};
|
|
let mut procs = Procs::default();
|
|
let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
|
|
|
|
// Populate Procs and get the low-level Expr from the canonical Expr
|
|
let main_body = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
|
|
|
|
// Put this module's ident_ids back in the interns, so we can use them in Env.
|
|
env.interns.all_ident_ids.insert(home, ident_ids);
|
|
|
|
let mut headers = Vec::with_capacity(procs.len());
|
|
|
|
// Add all the Proc headers to the module.
|
|
// We have to do this in a separate pass first,
|
|
// because their bodies may reference each other.
|
|
for (symbol, opt_proc) in procs.as_map().into_iter() {
|
|
if let Some(proc) = opt_proc {
|
|
let (fn_val, arg_basic_types) = build_proc_header(&env, symbol, &proc);
|
|
|
|
headers.push((proc, fn_val, arg_basic_types));
|
|
}
|
|
|
|
}
|
|
|
|
// Build each proc using its header info.
|
|
for (proc, fn_val, arg_basic_types) in headers {
|
|
// NOTE: This is here to be uncommented in case verification fails.
|
|
// (This approach means we don't have to defensively clone name here.)
|
|
//
|
|
// println!("\n\nBuilding and then verifying function {}\n\n", name);
|
|
build_proc(&env, proc, &procs, fn_val, arg_basic_types);
|
|
|
|
if fn_val.verify(true) {
|
|
fpm.run_on(&fn_val);
|
|
} else {
|
|
// NOTE: If this fails, uncomment the above println to debug.
|
|
panic!("Non-main function failed LLVM verification. Uncomment the above println to debug!");
|
|
}
|
|
}
|
|
|
|
// Add main to the module.
|
|
let main_fn = env.module.add_function(main_fn_name, main_fn_type, None);
|
|
|
|
// Add main's body
|
|
let basic_block = context.append_basic_block(main_fn, "entry");
|
|
|
|
builder.position_at_end(basic_block);
|
|
|
|
let ret = roc_gen::llvm::build::build_expr(
|
|
&env,
|
|
&ImMap::default(),
|
|
main_fn,
|
|
&main_body,
|
|
&mut Procs::default(),
|
|
);
|
|
|
|
builder.build_return(Some(&ret));
|
|
|
|
// Uncomment this to see the module's un-optimized LLVM instruction output:
|
|
// env.module.print_to_stderr();
|
|
|
|
if main_fn.verify(true) {
|
|
fpm.run_on(&main_fn);
|
|
} else {
|
|
panic!("Function {} failed LLVM verification.", main_fn_name);
|
|
}
|
|
|
|
// Verify the module
|
|
if let Err(errors) = env.module.verify() {
|
|
panic!("Errors defining module: {:?}", errors);
|
|
}
|
|
|
|
// Uncomment this to see the module's optimized LLVM instruction output:
|
|
// env.module.print_to_stderr();
|
|
|
|
unsafe {
|
|
let main: JitFunction<unsafe extern "C" fn() -> $ty> = execution_engine
|
|
.get_function(main_fn_name)
|
|
.ok()
|
|
.ok_or(format!("Unable to JIT compile `{}`", main_fn_name))
|
|
.expect("errored");
|
|
|
|
assert_eq!($transform(main.call()), $expected);
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! assert_evals_to {
|
|
($src:expr, $expected:expr, $ty:ty) => {
|
|
// Run Cranelift tests, then LLVM tests, in separate scopes.
|
|
// These each rebuild everything from scratch, starting with
|
|
// parsing the source, so that there's no chance their passing
|
|
// or failing depends on leftover state from the previous one.
|
|
{
|
|
assert_crane_evals_to!($src, $expected, $ty, (|val| val));
|
|
}
|
|
{
|
|
assert_llvm_evals_to!($src, $expected, $ty, (|val| val));
|
|
}
|
|
{
|
|
assert_opt_evals_to!($src, $expected, $ty, (|val| val));
|
|
}
|
|
};
|
|
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
|
|
// Same as above, except with an additional transformation argument.
|
|
{
|
|
assert_crane_evals_to!($src, $expected, $ty, $transform);
|
|
}
|
|
{
|
|
assert_llvm_evals_to!($src, $expected, $ty, $transform);
|
|
}
|
|
{
|
|
assert_opt_evals_to!($src, $expected, $ty, $transform);
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn basic_str() {
|
|
assert_evals_to!(
|
|
"\"shirt and hat\"",
|
|
CString::new("shirt and hat").unwrap().as_c_str(),
|
|
*const c_char,
|
|
CStr::from_ptr
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_int() {
|
|
assert_evals_to!("123", 123, i64);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_float() {
|
|
assert_evals_to!("1234.0", 1234.0, f64);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_list_len() {
|
|
assert_evals_to!("List.len []", 0, usize);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_int_list_len() {
|
|
assert_evals_to!("List.len [ 12, 9, 6, 3 ]", 4, usize);
|
|
}
|
|
|
|
// #[test]
|
|
// fn loaded_int_list_len() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// nums = [ 2, 4, 6 ]
|
|
|
|
// List.len nums
|
|
// "#
|
|
// ),
|
|
// 3,
|
|
// usize
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn fn_int_list_len() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// # TODO remove this annotation once monomorphization works!
|
|
// getLen = \list -> List.len list
|
|
|
|
// nums = [ 2, 4, 6 ]
|
|
|
|
// getLen nums
|
|
// "#
|
|
// ),
|
|
// 3,
|
|
// usize
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn int_list_is_empty() {
|
|
// assert_evals_to!("List.isEmpty [ 12, 9, 6, 3 ]", 0, u8, |x| x);
|
|
// }
|
|
//
|
|
#[test]
|
|
fn empty_list_literal() {
|
|
assert_llvm_evals_to!("[]", &[], &'static [i64], |x| x);
|
|
}
|
|
|
|
#[test]
|
|
fn int_list_literal() {
|
|
assert_llvm_evals_to!("[ 12, 9, 6, 3 ]", &[12, 9, 6, 3], &'static [i64], |x| x);
|
|
}
|
|
|
|
#[test]
|
|
fn head_int_list() {
|
|
assert_evals_to!("List.getUnsafe [ 12, 9, 6, 3 ] 0", 12, i64);
|
|
}
|
|
|
|
#[test]
|
|
fn get_int_list() {
|
|
assert_evals_to!("List.getUnsafe [ 12, 9, 6 ] 1", 9, i64);
|
|
}
|
|
|
|
#[test]
|
|
fn get_set_unique_int_list() {
|
|
assert_evals_to!("List.getUnsafe (List.set [ 12, 9, 7, 3 ] 1 42) 1", 42, i64);
|
|
}
|
|
|
|
#[test]
|
|
fn set_unique_int_list() {
|
|
assert_opt_evals_to!(
|
|
"List.set [ 12, 9, 7, 1, 5 ] 2 33",
|
|
&[12, 9, 33, 1, 5],
|
|
&'static [i64],
|
|
|x| x
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn set_unique_list_oob() {
|
|
assert_opt_evals_to!(
|
|
"List.set [ 3, 17, 4.1 ] 1337 9.25",
|
|
&[3.0, 17.0, 4.1],
|
|
&'static [f64],
|
|
|x| x
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn set_shared_int_list() {
|
|
assert_opt_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
shared = [ 2.1, 4.3 ]
|
|
|
|
# This should not mutate the original
|
|
x = List.getUnsafe (List.set shared 1 7.7) 1
|
|
|
|
{ x, y: List.getUnsafe shared 1 }
|
|
"#
|
|
),
|
|
(7.7, 4.3),
|
|
(f64, f64),
|
|
|x| x
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn set_shared_list_oob() {
|
|
assert_opt_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
shared = [ 2, 4 ]
|
|
|
|
# This List.set is out of bounds, and should have no effect
|
|
x = List.getUnsafe (List.set shared 422 0) 1
|
|
|
|
{ x, y: List.getUnsafe shared 1 }
|
|
"#
|
|
),
|
|
(4, 4),
|
|
(i64, i64),
|
|
|x| x
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn get_unique_int_list() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
shared = [ 2, 4 ]
|
|
|
|
List.getUnsafe shared 1
|
|
"#
|
|
),
|
|
4,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_first_float() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 1.23 is
|
|
1.23 -> 12
|
|
_ -> 34
|
|
"#
|
|
),
|
|
12,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_second_float() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2.34 is
|
|
1.23 -> 63
|
|
_ -> 48
|
|
"#
|
|
),
|
|
48,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_third_float() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 10.0 is
|
|
1.0 -> 63
|
|
2.0 -> 48
|
|
_ -> 112
|
|
"#
|
|
),
|
|
112,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_first_int() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 1 is
|
|
1 -> 12
|
|
_ -> 34
|
|
"#
|
|
),
|
|
12,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_second_int() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2 is
|
|
1 -> 63
|
|
_ -> 48
|
|
"#
|
|
),
|
|
48,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_third_int() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 10 is
|
|
1 -> 63
|
|
2 -> 48
|
|
_ -> 112
|
|
"#
|
|
),
|
|
112,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn branch_store_variable() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 0 is
|
|
1 -> 12
|
|
a -> a
|
|
"#
|
|
),
|
|
0,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn one_element_tag() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : [ Pair Int ]
|
|
x = Pair 2
|
|
|
|
0x3
|
|
"#
|
|
),
|
|
3,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_one_element_tag() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : [ Pair Int Int ]
|
|
x = Pair 0x2 0x3
|
|
|
|
when x is
|
|
Pair l r -> l + r
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn twice_record_access() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x = {a: 0x2, b: 0x3 }
|
|
|
|
x.a + x.b
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_when_one_branch() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 3.14 is
|
|
_ -> 23
|
|
"#
|
|
),
|
|
23,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_large_when_int() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
foo = \num ->
|
|
when num is
|
|
0 -> 200
|
|
-3 -> 111 # TODO adding more negative numbers reproduces parsing bugs here
|
|
3 -> 789
|
|
1 -> 123
|
|
2 -> 456
|
|
_ -> 1000
|
|
|
|
foo -3
|
|
"#
|
|
),
|
|
111,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn int_negate() {
|
|
assert_evals_to!("Num.neg 123", -123, i64);
|
|
}
|
|
|
|
// #[test]
|
|
// fn gen_large_when_float() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// foo = \num ->
|
|
// when num is
|
|
// 0.5 -> 200.1
|
|
// -3.6 -> 111.2 # TODO adding more negative numbers reproduces parsing bugs here
|
|
// 3.6 -> 789.5
|
|
// 1.7 -> 123.3
|
|
// 2.8 -> 456.4
|
|
// _ -> 1000.6
|
|
|
|
// foo -3.6
|
|
// "#
|
|
// ),
|
|
// 111.2,
|
|
// f64
|
|
// );
|
|
// }
|
|
|
|
#[test]
|
|
fn gen_basic_def() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
answer = 42
|
|
|
|
answer
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
pi = 3.14
|
|
|
|
pi
|
|
"#
|
|
),
|
|
3.14,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_multiple_defs() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
answer = 42
|
|
|
|
pi = 3.14
|
|
|
|
answer
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
answer = 42
|
|
|
|
pi = 3.14
|
|
|
|
pi
|
|
"#
|
|
),
|
|
3.14,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_chained_defs() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x = i1
|
|
i3 = i2
|
|
i1 = 1337
|
|
i2 = i1
|
|
y = 12.4
|
|
|
|
i3
|
|
"#
|
|
),
|
|
1337,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_nested_defs() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x = 5
|
|
|
|
answer =
|
|
i3 = i2
|
|
|
|
nested =
|
|
a = 1.0
|
|
b = 5
|
|
|
|
i1
|
|
|
|
i1 = 1337
|
|
i2 = i1
|
|
|
|
|
|
nested
|
|
|
|
# None of this should affect anything, even though names
|
|
# overlap with the previous nested defs
|
|
unused =
|
|
nested = 17
|
|
|
|
i1 = 84.2
|
|
|
|
nested
|
|
|
|
y = 12.4
|
|
|
|
answer
|
|
"#
|
|
),
|
|
1337,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_basic_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
always42 : Num.Num Int.Integer -> Num.Num Int.Integer
|
|
always42 = \num -> 42
|
|
|
|
always42 5
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_when_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
limitedNegate = \num ->
|
|
when num is
|
|
1 -> -1
|
|
-1 -> 1
|
|
_ -> num
|
|
|
|
limitedNegate 1
|
|
"#
|
|
),
|
|
-1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_if_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
limitedNegate = \num ->
|
|
if num == 1 then
|
|
-1
|
|
else if num == -1 then
|
|
1
|
|
else
|
|
num
|
|
|
|
limitedNegate 1
|
|
"#
|
|
),
|
|
-1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_float_eq() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1.0 == 1.0
|
|
"#
|
|
),
|
|
true,
|
|
bool
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_literal_true() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
if True then -1 else 1
|
|
"#
|
|
),
|
|
-1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_if_float_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
if True then -1.0 else 1.0
|
|
"#
|
|
),
|
|
-1.0,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn apply_identity_() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
identity = \a -> a
|
|
|
|
identity 5
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn apply_unnamed_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
(\a -> a) 5
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_add_f64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1.1 + 2.4 + 3
|
|
"#
|
|
),
|
|
6.5,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_add_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 + 2 + 3
|
|
"#
|
|
),
|
|
6,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_sub_f64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1.5 - 2.4 - 3
|
|
"#
|
|
),
|
|
-3.9,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_sub_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 - 2 - 3
|
|
"#
|
|
),
|
|
-4,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_mul_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
2 * 4 * 6
|
|
"#
|
|
),
|
|
48,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_order_of_arithmetic_ops() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 + 3 * 7 - 2
|
|
"#
|
|
),
|
|
20,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn return_unnamed_fn() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
alwaysFloatIdentity : Int -> (Float -> Float)
|
|
alwaysFloatIdentity = \num ->
|
|
(\a -> a)
|
|
|
|
(alwaysFloatIdentity 2) 3.14
|
|
"#
|
|
),
|
|
3.14,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_enum() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Fruit : [ Apple, Orange, Banana ]
|
|
|
|
apple : Fruit
|
|
apple = Apple
|
|
|
|
orange : Fruit
|
|
orange = Orange
|
|
|
|
apple == orange
|
|
"#
|
|
),
|
|
false,
|
|
bool
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_enum() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Fruit : [ Apple, Orange, Banana ]
|
|
|
|
apple : Fruit
|
|
apple = Apple
|
|
|
|
when apple is
|
|
Apple -> 1
|
|
Banana -> 2
|
|
Orange -> 3
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn applied_tag_nothing() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Just a, Nothing ]
|
|
|
|
x : Maybe Int
|
|
x = Nothing
|
|
|
|
0x1
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
#[test]
|
|
fn applied_tag_just() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Just a, Nothing ]
|
|
|
|
y : Maybe Int
|
|
y = Just 0x4
|
|
|
|
0x1
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn applied_tag_just_unit() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Fruit : [ Orange, Apple, Banana ]
|
|
Maybe a : [ Just a, Nothing ]
|
|
|
|
orange : Fruit
|
|
orange = Orange
|
|
|
|
y : Maybe Fruit
|
|
y = Just orange
|
|
|
|
0x1
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_nothing() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : [ Nothing, Just Int ]
|
|
x = Nothing
|
|
|
|
when x is
|
|
Nothing -> 0x2
|
|
Just _ -> 0x1
|
|
"#
|
|
),
|
|
2,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_just() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : [ Nothing, Just Int ]
|
|
x = Just 41
|
|
|
|
when x is
|
|
Just v -> v + 0x1
|
|
Nothing -> 0x1
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_result() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : Result Int Int
|
|
x = Err 41
|
|
|
|
when x is
|
|
Err v -> v + 1
|
|
Ok _ -> 1
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_these() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
These a b : [ This a, That b, These a b ]
|
|
|
|
x : These Int Int
|
|
x = These 0x3 0x2
|
|
|
|
when x is
|
|
These a b -> a + b
|
|
That v -> 8
|
|
This v -> v
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn match_on_two_values() {
|
|
// this will produce a Chain internally
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when Pair 2 3 is
|
|
Pair 4 3 -> 9
|
|
Pair a b -> a + b
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn pair_with_guard_pattern() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when Pair 2 3 is
|
|
Pair 4 _ -> 1
|
|
Pair 3 _ -> 2
|
|
Pair a b -> a + b
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn result_with_guard_pattern() {
|
|
// This test revealed an issue with hashing Test values
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : Result Int Int
|
|
x = Ok 2
|
|
|
|
when x is
|
|
Ok 3 -> 1
|
|
Ok _ -> 2
|
|
Err _ -> 3
|
|
"#
|
|
),
|
|
2,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn maybe_is_just() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Just a, Nothing ]
|
|
|
|
isJust : Maybe a -> Bool
|
|
isJust = \list ->
|
|
when list is
|
|
Nothing -> False
|
|
Just _ -> True
|
|
|
|
isJust (Just 42)
|
|
"#
|
|
),
|
|
true,
|
|
bool
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn when_on_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when { x: 0x2 } is
|
|
{ x } -> x + 3
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when { x: 0x2, y: 3.14 } is
|
|
{ x: var } -> var + 3
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
{ x } = { x: 0x2, y: 3.14 }
|
|
|
|
x
|
|
"#
|
|
),
|
|
2,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn record_guard_pattern() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when { x: 0x2, y: 3.14 } is
|
|
{ x: 0x4 } -> 5
|
|
{ x } -> x + 3
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_tag_union() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Nothing, Just a ]
|
|
|
|
x : Maybe (Maybe a)
|
|
x = Just (Just 41)
|
|
|
|
5
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_load() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Nothing, Just a ]
|
|
|
|
x = { a : { b : 0x5 } }
|
|
|
|
y = x.a
|
|
|
|
y.b
|
|
"#
|
|
),
|
|
5,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_pattern_match() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Maybe a : [ Nothing, Just a ]
|
|
|
|
x : Maybe (Maybe Int)
|
|
x = Just (Just 41)
|
|
|
|
when x is
|
|
Just (Just v) -> v + 0x1
|
|
_ -> 0x1
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn or_pattern() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2 is
|
|
1 | 2 -> 42
|
|
_ -> 1
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn if_guard_pattern_false() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2 is
|
|
2 if False -> 0
|
|
_ -> 42
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn if_guard_pattern_true() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2 is
|
|
2 if True -> 42
|
|
_ -> 0
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn if_guard_exhaustiveness() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 2 is
|
|
_ if False -> 0
|
|
_ -> 42
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn if_guard_bind_variable() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 10 is
|
|
x if x == 5 -> 0
|
|
_ -> 42
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when 10 is
|
|
x if x == 10 -> 42
|
|
_ -> 0
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
// #[test]
|
|
// fn linked_list_empty() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// LinkedList a : [ Cons a (LinkedList a), Nil ]
|
|
//
|
|
// empty : LinkedList Int
|
|
// empty = Nil
|
|
//
|
|
// 1
|
|
// "#
|
|
// ),
|
|
// 1,
|
|
// i64
|
|
// );
|
|
// }
|
|
//
|
|
// #[test]
|
|
// fn linked_list_singleton() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// LinkedList a : [ Cons a (LinkedList a), Nil ]
|
|
//
|
|
// singleton : LinkedList Int
|
|
// singleton = Cons 0x1 Nil
|
|
//
|
|
// 1
|
|
// "#
|
|
// ),
|
|
// 1,
|
|
// i64
|
|
// );
|
|
// }
|
|
//
|
|
// #[test]
|
|
// fn linked_list_is_empty() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// LinkedList a : [ Cons a (LinkedList a), Nil ]
|
|
//
|
|
// isEmpty : LinkedList a -> Bool
|
|
// isEmpty = \list ->
|
|
// when list is
|
|
// Nil -> True
|
|
// Cons _ _ -> False
|
|
//
|
|
// isEmpty (Cons 4 Nil)
|
|
// "#
|
|
// ),
|
|
// false,
|
|
// bool
|
|
// );
|
|
// }
|
|
|
|
#[test]
|
|
fn empty_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
v = {}
|
|
|
|
1
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unit_type() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Unit : [ Unit ]
|
|
|
|
v : Unit
|
|
v = Unit
|
|
|
|
1
|
|
"#
|
|
),
|
|
1,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn pattern_matching_unit() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Unit : [ Unit ]
|
|
|
|
f : Unit -> Int
|
|
f = \Unit -> 42
|
|
|
|
f Unit
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
Unit : [ Unit ]
|
|
|
|
x : Unit
|
|
x = Unit
|
|
|
|
when x is
|
|
Unit -> 42
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
f : {} -> Int
|
|
f = \{} -> 42
|
|
|
|
f {}
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when {} is
|
|
{} -> 42
|
|
"#
|
|
),
|
|
42,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn basic_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
{ y: 17, x: 15, z: 19 }.x
|
|
"#
|
|
),
|
|
15,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
{ x: 15, y: 17, z: 19 }.y
|
|
"#
|
|
),
|
|
17,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
{ x: 15, y: 17, z: 19 }.z
|
|
"#
|
|
),
|
|
19,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn def_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { y: 17, x: 15, z: 19 }
|
|
|
|
rec.x
|
|
"#
|
|
),
|
|
15,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { x: 15, y: 17, z: 19 }
|
|
|
|
rec.y
|
|
"#
|
|
),
|
|
17,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { x: 15, y: 17, z: 19 }
|
|
|
|
rec.z
|
|
"#
|
|
),
|
|
19,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fn_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
getRec = \x -> { y: 17, x, z: 19 }
|
|
|
|
(getRec 15).x
|
|
"#
|
|
),
|
|
15,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { x: 15, y: 17, z: 19 }
|
|
|
|
rec.y
|
|
"#
|
|
),
|
|
17,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { x: 15, y: 17, z: 19 }
|
|
|
|
rec.z
|
|
"#
|
|
),
|
|
19,
|
|
i64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { x: 15, y: 17, z: 19 }
|
|
|
|
rec.z + rec.x
|
|
"#
|
|
),
|
|
34,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn f64_record() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { y: 17.2, x: 15.1, z: 19.3 }
|
|
|
|
rec.x
|
|
"#
|
|
),
|
|
15.1,
|
|
f64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { y: 17.2, x: 15.1, z: 19.3 }
|
|
|
|
rec.y
|
|
"#
|
|
),
|
|
17.2,
|
|
f64
|
|
);
|
|
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
rec = { y: 17.2, x: 15.1, z: 19.3 }
|
|
|
|
rec.z
|
|
"#
|
|
),
|
|
19.3,
|
|
f64
|
|
);
|
|
}
|
|
#[test]
|
|
fn bool_literal() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : Bool
|
|
x = True
|
|
|
|
x
|
|
"#
|
|
),
|
|
true,
|
|
bool
|
|
);
|
|
}
|
|
}
|