language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-03 16:44:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

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
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 // len : List * -> Int
add_type( add_type(
Symbol::LIST_LEN, 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)) // concat : Attr * (List (Attr * a)), Attr * (List (Attr * a)) -> Attr * (List (Attr * a))
add_type(Symbol::LIST_APPEND, { add_type(Symbol::LIST_CONCAT, {
let_tvars! { a, star1, star2, star3 }; let_tvars! { a, star1, star2, star3 };
unique_function( 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_SINGLE => list_single,
Symbol::LIST_REPEAT => list_repeat, Symbol::LIST_REPEAT => list_repeat,
Symbol::LIST_REVERSE => list_reverse, Symbol::LIST_REVERSE => list_reverse,
Symbol::LIST_APPEND => list_append, Symbol::LIST_CONCAT => list_concat,
Symbol::NUM_ADD => num_add, Symbol::NUM_ADD => num_add,
Symbol::NUM_SUB => num_sub, Symbol::NUM_SUB => num_sub,
Symbol::NUM_MUL => num_mul, 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 /// List.concat : List elem, List elem -> List elem
fn list_append(symbol: Symbol, var_store: &mut VarStore) -> Def { fn list_concat(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh(); let list_var = var_store.fresh();
let body = RunLowLevel { let body = RunLowLevel {
op: LowLevel::ListAppend, op: LowLevel::ListConcat,
args: vec![ args: vec![
(list_var, Var(Symbol::ARG_1)), (list_var, Var(Symbol::ARG_1)),
(list_var, Var(Symbol::ARG_2)), (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 => { ListPush => {
// List.push List elem, elem -> List elem // List.push List elem, elem -> List elem
debug_assert_eq!(args.len(), 2); 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>, env: &Env<'a, 'ctx, 'env>,
layout_ids: &mut LayoutIds<'a>, layout_ids: &mut LayoutIds<'a>,
scope: &Scope<'a, 'ctx>, scope: &Scope<'a, 'ctx>,
parent: FunctionValue<'ctx>, parent: FunctionValue<'ctx>,
args: &[(Expr<'a>, Layout<'a>)], args: &[(Expr<'a>, Layout<'a>)],
) -> BasicValueEnum<'ctx> { ) -> BasicValueEnum<'ctx> {
// List.append : List elem, List elem -> List elem // List.concat : List elem, List elem -> List elem
debug_assert_eq!(args.len(), 2); debug_assert_eq!(args.len(), 2);
// This implementation is quite long, let me explain what is complicating it. Here are our // 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!( unreachable!(
"Invalid List layout for second input list of List.append: {:?}", "Invalid List layout for second input list of List.concat: {:?}",
second_list_layout second_list_layout
); );
} }
@ -2239,7 +2239,7 @@ fn list_append<'a, 'ctx, 'env>(
// FIRST LOOP // FIRST LOOP
{ {
let first_loop_bb = 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.build_unconditional_branch(first_loop_bb);
builder.position_at_end(first_loop_bb); builder.position_at_end(first_loop_bb);
@ -2310,7 +2310,7 @@ fn list_append<'a, 'ctx, 'env>(
// SECOND LOOP // SECOND LOOP
{ {
let second_loop_bb = 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.build_unconditional_branch(second_loop_bb);
builder.position_at_end(second_loop_bb); builder.position_at_end(second_loop_bb);
@ -2436,7 +2436,7 @@ fn list_append<'a, 'ctx, 'env>(
} }
_ => { _ => {
unreachable!( unreachable!(
"Invalid List layout for second input list of List.append: {:?}", "Invalid List layout for second input list of List.concat: {:?}",
second_list_layout second_list_layout
); );
} }
@ -2481,7 +2481,7 @@ fn list_append<'a, 'ctx, 'env>(
} }
_ => { _ => {
unreachable!( unreachable!(
"Invalid List layout for second input list of List.append: {:?}", "Invalid List layout for second input list of List.concat: {:?}",
second_list_layout second_list_layout
); );
} }
@ -2499,7 +2499,7 @@ fn list_append<'a, 'ctx, 'env>(
} }
_ => { _ => {
unreachable!( unreachable!(
"Invalid List layout for first list in List.append : {:?}", "Invalid List layout for first list in List.concat : {:?}",
first_list_layout first_list_layout
); );
} }

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

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

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

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

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

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