roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-22 00:09:33 +03:00
Code Issues Packages Projects Releases Wiki Activity

Renamed List.append to List.concat

Browse Source
This commit is contained in:
Chad Stearns 2020-07-24 01:12:19 -04:00
parent 74fa1bc56d
commit 0b078783fd
7 changed files with 60 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
compiler/builtins/src/std.rs
View File

@ -543,15 +543,6 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
),
);
// append : List elem, List elem -> List elem
add_type(
Symbol::LIST_APPEND,
SolvedType::Func(
vec![list_type(flex(TVAR1)), list_type(flex(TVAR1))],
Box::new(list_type(flex(TVAR1))),
),
);
// len : List * -> Int
add_type(
Symbol::LIST_LEN,

4
compiler/builtins/src/unique.rs
View File

@ -638,8 +638,8 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
)
});
// append : Attr * (List (Attr * a)), Attr * (List (Attr * a)) -> Attr * (List (Attr * a))
add_type(Symbol::LIST_APPEND, {
// concat : Attr * (List (Attr * a)), Attr * (List (Attr * a)) -> Attr * (List (Attr * a))
add_type(Symbol::LIST_CONCAT, {
let_tvars! { a, star1, star2, star3 };
unique_function(

8
compiler/can/src/builtins.rs
View File

@ -59,7 +59,7 @@ pub fn builtin_defs(var_store: &mut VarStore) -> MutMap<Symbol, Def> {
Symbol::LIST_SINGLE => list_single,
Symbol::LIST_REPEAT => list_repeat,
Symbol::LIST_REVERSE => list_reverse,
Symbol::LIST_APPEND => list_append,
Symbol::LIST_CONCAT => list_concat,
Symbol::NUM_ADD => num_add,
Symbol::NUM_SUB => num_sub,
Symbol::NUM_MUL => num_mul,
@ -617,12 +617,12 @@ fn list_reverse(symbol: Symbol, var_store: &mut VarStore) -> Def {
)
}
/// List.append : List elem, List elem -> List elem
fn list_append(symbol: Symbol, var_store: &mut VarStore) -> Def {
/// List.concat : List elem, List elem -> List elem
fn list_concat(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let body = RunLowLevel {
op: LowLevel::ListAppend,
op: LowLevel::ListConcat,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(list_var, Var(Symbol::ARG_2)),

18
compiler/gen/src/llvm/build.rs
View File

@ -1819,7 +1819,7 @@ fn run_low_level<'a, 'ctx, 'env>(
}
}
}
ListAppend => list_append(env, layout_ids, scope, parent, args),
ListConcat => list_concat(env, layout_ids, scope, parent, args),
ListPush => {
// List.push List elem, elem -> List elem
debug_assert_eq!(args.len(), 2);
@ -2066,14 +2066,14 @@ fn build_int_binop<'a, 'ctx, 'env>(
}
}
fn list_append<'a, 'ctx, 'env>(
fn list_concat<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
layout_ids: &mut LayoutIds<'a>,
scope: &Scope<'a, 'ctx>,
parent: FunctionValue<'ctx>,
args: &[(Expr<'a>, Layout<'a>)],
) -> BasicValueEnum<'ctx> {
// List.append : List elem, List elem -> List elem
// List.concat : List elem, List elem -> List elem
debug_assert_eq!(args.len(), 2);
// This implementation is quite long, let me explain what is complicating it. Here are our
@ -2162,7 +2162,7 @@ fn list_append<'a, 'ctx, 'env>(
}
_ => {
unreachable!(
"Invalid List layout for second input list of List.append: {:?}",
"Invalid List layout for second input list of List.concat: {:?}",
second_list_layout
);
}
@ -2239,7 +2239,7 @@ fn list_append<'a, 'ctx, 'env>(
// FIRST LOOP
{
let first_loop_bb =
ctx.append_basic_block(parent, "first_list_append_loop");
ctx.append_basic_block(parent, "first_list_concat_loop");
builder.build_unconditional_branch(first_loop_bb);
builder.position_at_end(first_loop_bb);
@ -2310,7 +2310,7 @@ fn list_append<'a, 'ctx, 'env>(
// SECOND LOOP
{
let second_loop_bb =
ctx.append_basic_block(parent, "second_list_append_loop");
ctx.append_basic_block(parent, "second_list_concat_loop");
builder.build_unconditional_branch(second_loop_bb);
builder.position_at_end(second_loop_bb);
@ -2436,7 +2436,7 @@ fn list_append<'a, 'ctx, 'env>(
}
_ => {
unreachable!(
"Invalid List layout for second input list of List.append: {:?}",
"Invalid List layout for second input list of List.concat: {:?}",
second_list_layout
);
}
@ -2481,7 +2481,7 @@ fn list_append<'a, 'ctx, 'env>(
}
_ => {
unreachable!(
"Invalid List layout for second input list of List.append: {:?}",
"Invalid List layout for second input list of List.concat: {:?}",
second_list_layout
);
}
@ -2499,7 +2499,7 @@ fn list_append<'a, 'ctx, 'env>(
}
_ => {
unreachable!(
"Invalid List layout for first list in List.append : {:?}",
"Invalid List layout for first list in List.concat : {:?}",
first_list_layout
);
}

88
compiler/gen/tests/gen_list.rs
View File

@ -126,8 +126,8 @@ mod gen_list {
}
#[test]
fn list_append() {
assert_evals_to!("List.append [] []", &[], &'static [i64]);
fn list_concat() {
assert_evals_to!("List.concat [] []", &[], &'static [i64]);
assert_evals_to!(
indoc!(
@ -140,30 +140,30 @@ mod gen_list {
secondList =
[]
List.append firstList secondList
List.concat firstList secondList
"#
),
&[],
&'static [i64]
);
assert_evals_to!("List.append [ 12, 13 ] []", &[12, 13], &'static [i64]);
assert_evals_to!("List.concat [ 12, 13 ] []", &[12, 13], &'static [i64]);
assert_evals_to!(
"List.append [ 34, 43 ] [ 64, 55, 66 ]",
"List.concat [ 34, 43 ] [ 64, 55, 66 ]",
&[34, 43, 64, 55, 66],
&'static [i64]
);
assert_evals_to!("List.append [] [ 23, 24 ]", &[23, 24], &'static [i64]);
assert_evals_to!("List.concat [] [ 23, 24 ]", &[23, 24], &'static [i64]);
assert_evals_to!(
"List.append [ 1, 2 ] [ 3, 4 ]",
"List.concat [ 1, 2 ] [ 3, 4 ]",
&[1, 2, 3, 4],
&'static [i64]
);
}
fn assert_append_worked(num_elems1: i64, num_elems2: i64) {
fn assert_concat_worked(num_elems1: i64, num_elems2: i64) {
let vec1: Vec<i64> = (0..num_elems1)
.map(|i| 12345 % (i + num_elems1 + num_elems2 + 1))
.collect();
@ -179,51 +179,51 @@ mod gen_list {
let expected_slice: &[i64] = expected.as_ref();
assert_evals_to!(
&format!("List.append {} {}", slice_str1, slice_str2),
&format!("List.concat {} {}", slice_str1, slice_str2),
expected_slice,
&'static [i64]
);
}
#[test]
fn list_append_empty_list() {
assert_append_worked(0, 0);
assert_append_worked(1, 0);
assert_append_worked(2, 0);
assert_append_worked(3, 0);
assert_append_worked(4, 0);
assert_append_worked(7, 0);
assert_append_worked(8, 0);
assert_append_worked(9, 0);
assert_append_worked(25, 0);
assert_append_worked(150, 0);
assert_append_worked(0, 1);
assert_append_worked(0, 2);
assert_append_worked(0, 3);
assert_append_worked(0, 4);
assert_append_worked(0, 7);
assert_append_worked(0, 8);
assert_append_worked(0, 9);
assert_append_worked(0, 25);
assert_append_worked(0, 150);
fn list_concat_empty_list() {
assert_concat_worked(0, 0);
assert_concat_worked(1, 0);
assert_concat_worked(2, 0);
assert_concat_worked(3, 0);
assert_concat_worked(4, 0);
assert_concat_worked(7, 0);
assert_concat_worked(8, 0);
assert_concat_worked(9, 0);
assert_concat_worked(25, 0);
assert_concat_worked(150, 0);
assert_concat_worked(0, 1);
assert_concat_worked(0, 2);
assert_concat_worked(0, 3);
assert_concat_worked(0, 4);
assert_concat_worked(0, 7);
assert_concat_worked(0, 8);
assert_concat_worked(0, 9);
assert_concat_worked(0, 25);
assert_concat_worked(0, 150);
}
#[test]
fn list_append_nonempty_lists() {
assert_append_worked(1, 1);
assert_append_worked(1, 2);
assert_append_worked(1, 3);
assert_append_worked(2, 3);
assert_append_worked(2, 1);
assert_append_worked(2, 2);
assert_append_worked(3, 1);
assert_append_worked(3, 2);
assert_append_worked(2, 3);
assert_append_worked(3, 3);
assert_append_worked(4, 4);
assert_append_worked(150, 150);
assert_append_worked(129, 350);
assert_append_worked(350, 129);
fn list_concat_nonempty_lists() {
assert_concat_worked(1, 1);
assert_concat_worked(1, 2);
assert_concat_worked(1, 3);
assert_concat_worked(2, 3);
assert_concat_worked(2, 1);
assert_concat_worked(2, 2);
assert_concat_worked(3, 1);
assert_concat_worked(3, 2);
assert_concat_worked(2, 3);
assert_concat_worked(3, 3);
assert_concat_worked(4, 4);
assert_concat_worked(150, 150);
assert_concat_worked(129, 350);
assert_concat_worked(350, 129);
}
#[test]

2
compiler/module/src/low_level.rs
View File

@ -10,7 +10,7 @@ pub enum LowLevel {
ListSingle,
ListRepeat,
ListReverse,
ListAppend,
ListConcat,
ListPush,
NumAdd,
NumSub,

1
compiler/module/src/symbol.rs
View File

@ -658,7 +658,6 @@ define_builtins! {
12 LIST_SINGLE: "single"
13 LIST_REPEAT: "repeat"
14 LIST_REVERSE: "reverse"
15 LIST_APPEND: "append"
}
5 RESULT: "Result" => {
0 RESULT_RESULT: "Result" imported // the Result.Result type alias