language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 12:18:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge branch 'trunk' of github.com:rtfeldman/roc into crates-folder

Browse source
This commit is contained in:
Anton-4 2022-07-01 17:43:05 +02:00
commit ef68d821f1
No known key found for this signature in database
GPG key ID: C954D6E0F9C0ABFD
3 changed files with 34 additions and 774 deletions
Download patch file Download diff file Expand all files Collapse all files

783
crates/compiler/can/src/builtins.rs
View file

@ -102,8 +102,8 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
STR_TO_U8 => str_to_num,
STR_TO_I8 => str_to_num,
LIST_LEN => list_len,
LIST_GET => list_get,
LIST_REPLACE => list_replace,
LIST_GET_UNSAFE => list_get_unsafe,
LIST_REPLACE_UNSAFE => list_replace_unsafe,
LIST_SET => list_set,
LIST_APPEND => list_append,
LIST_FIRST => list_first,
@ -114,10 +114,6 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
LIST_REVERSE => list_reverse,
LIST_CONCAT => list_concat,
LIST_CONTAINS => list_contains,
LIST_MIN => list_min,
LIST_MAX => list_max,
LIST_SUM => list_sum,
LIST_PRODUCT => list_product,
LIST_PREPEND => list_prepend,
LIST_JOIN => list_join,
LIST_JOIN_MAP => list_join_map,
@ -132,9 +128,6 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
LIST_INTERSPERSE => list_intersperse,
LIST_DROP => list_drop,
LIST_DROP_AT => list_drop_at,
LIST_DROP_FIRST => list_drop_first,
LIST_DROP_IF => list_drop_if,
LIST_DROP_LAST => list_drop_last,
LIST_SWAP => list_swap,
LIST_MAP_WITH_INDEX => list_map_with_index,
LIST_KEEP_IF => list_keep_if,
@ -145,8 +138,6 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
LIST_WALK_BACKWARDS => list_walk_backwards,
LIST_WALK_UNTIL => list_walk_until,
LIST_SORT_WITH => list_sort_with,
LIST_SORT_ASC => list_sort_asc,
LIST_SORT_DESC => list_sort_desc,
LIST_ANY => list_any,
LIST_ALL => list_all,
LIST_FIND => list_find,
@ -2179,176 +2170,17 @@ fn list_len(symbol: Symbol, var_store: &mut VarStore) -> Def {
)
}
/// List.get : List elem, Int -> Result elem [OutOfBounds]*
///
/// List.get :
/// Attr (* | u) (List (Attr u a)),
/// Attr * Int
/// -> Attr * (Result (Attr u a) (Attr * [OutOfBounds]*))
fn list_get(symbol: Symbol, var_store: &mut VarStore) -> Def {
let arg_list = Symbol::ARG_1;
let arg_index = Symbol::ARG_2;
let bool_var = var_store.fresh();
let len_var = var_store.fresh();
let list_var = var_store.fresh();
let elem_var = var_store.fresh();
let ret_var = var_store.fresh();
// Perform a bounds check. If it passes, run LowLevel::ListGetUnsafe
let body = If {
cond_var: bool_var,
branch_var: var_store.fresh(),
branches: vec![(
// if-condition
no_region(
// index < List.len list
RunLowLevel {
op: LowLevel::NumLt,
args: vec![
(len_var, Var(arg_index)),
(
len_var,
RunLowLevel {
op: LowLevel::ListLen,
args: vec![(list_var, Var(arg_list))],
ret_var: len_var,
},
),
],
ret_var: bool_var,
},
),
// then-branch
no_region(
// Ok
tag(
"Ok",
vec![
// List#getUnsafe list index
RunLowLevel {
op: LowLevel::ListGetUnsafe,
args: vec![(list_var, Var(arg_list)), (len_var, Var(arg_index))],
ret_var: elem_var,
},
],
var_store,
),
),
)],
final_else: Box::new(
// else-branch
no_region(
// Err
tag(
"Err",
vec![tag("OutOfBounds", Vec::new(), var_store)],
var_store,
),
),
),
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1), (len_var, Symbol::ARG_2)],
var_store,
body,
ret_var,
)
/// List.getUnsafe : List elem, Int -> elem
fn list_get_unsafe(symbol: Symbol, var_store: &mut VarStore) -> Def {
lowlevel_2(symbol, LowLevel::ListGetUnsafe, var_store)
}
/// List.replace : List elem, Nat, elem -> { list: List elem, value: elem }
fn list_replace(symbol: Symbol, var_store: &mut VarStore) -> Def {
let arg_list = Symbol::ARG_1;
let arg_index = Symbol::ARG_2;
let arg_elem = Symbol::ARG_3;
let bool_var = var_store.fresh();
let len_var = var_store.fresh();
let elem_var = var_store.fresh();
let list_arg_var = var_store.fresh();
let ret_record_var = var_store.fresh();
let ret_result_var = var_store.fresh();
let list_field = Field {
var: list_arg_var,
region: Region::zero(),
loc_expr: Box::new(Loc::at_zero(Expr::Var(arg_list))),
};
let value_field = Field {
var: elem_var,
region: Region::zero(),
loc_expr: Box::new(Loc::at_zero(Expr::Var(arg_elem))),
};
// Perform a bounds check. If it passes, run LowLevel::ListReplaceUnsafe.
// Otherwise, return the list unmodified.
let body = If {
cond_var: bool_var,
branch_var: ret_result_var,
branches: vec![(
// if-condition
no_region(
// index < List.len list
RunLowLevel {
op: LowLevel::NumLt,
args: vec![
(len_var, Var(arg_index)),
(
len_var,
RunLowLevel {
op: LowLevel::ListLen,
args: vec![(list_arg_var, Var(arg_list))],
ret_var: len_var,
},
),
],
ret_var: bool_var,
},
),
// then-branch
no_region(
// List.replaceUnsafe list index elem
RunLowLevel {
op: LowLevel::ListReplaceUnsafe,
args: vec![
(list_arg_var, Var(arg_list)),
(len_var, Var(arg_index)),
(elem_var, Var(arg_elem)),
],
ret_var: ret_record_var,
},
),
)],
final_else: Box::new(
// else-branch
no_region(record(
vec![("list".into(), list_field), ("value".into(), value_field)],
var_store,
)),
),
};
defn(
symbol,
vec![
(list_arg_var, Symbol::ARG_1),
(len_var, Symbol::ARG_2),
(elem_var, Symbol::ARG_3),
],
var_store,
body,
ret_result_var,
)
/// List.replaceUnsafe : List elem, Nat, elem -> { list: List elem, value: elem }
fn list_replace_unsafe(symbol: Symbol, var_store: &mut VarStore) -> Def {
lowlevel_3(symbol, LowLevel::ListReplaceUnsafe, var_store)
}
/// List.set : List elem, Nat, elem -> List elem
///
/// List.set :
/// Attr (w | u | v) (List (Attr u a)),
/// Attr * Int,
/// Attr (u | v) a
/// -> Attr * (List (Attr u a))
fn list_set(symbol: Symbol, var_store: &mut VarStore) -> Def {
let arg_list = Symbol::ARG_1;
let arg_index = Symbol::ARG_2;
@ -2846,161 +2678,9 @@ fn list_drop(symbol: Symbol, var_store: &mut VarStore) -> Def {
/// List.dropAt : List elem, Nat -> List elem
fn list_drop_at(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let index_var = var_store.fresh();
let body = RunLowLevel {
op: LowLevel::ListDropAt,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(index_var, Var(Symbol::ARG_2)),
],
ret_var: list_var,
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1), (index_var, Symbol::ARG_2)],
var_store,
body,
list_var,
)
lowlevel_2(symbol, LowLevel::ListDropAt, var_store)
}
/// List.dropFirst : List elem -> Result { first: elem, others : List elem } [ListWasEmpty]*
fn list_drop_first(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let index_var = var_store.fresh();
let num_var = Variable::NAT;
let num_precision_var = Variable::NATURAL;
let body = RunLowLevel {
op: LowLevel::ListDropAt,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(
index_var,
int::<i128>(num_var, num_precision_var, 0, int_no_bound()),
),
],
ret_var: list_var,
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
list_var,
)
}
/// List.dropIf : List elem, (elem -> Bool) -> List elem
fn list_drop_if(symbol: Symbol, var_store: &mut VarStore) -> Def {
let sym_list = Symbol::ARG_1;
let sym_predicate = Symbol::ARG_2;
let t_list = var_store.fresh();
let t_predicate = var_store.fresh();
let t_keep_predicate = var_store.fresh();
let t_elem = var_store.fresh();
// Defer to keepIf for implementation
// List.dropIf l p = List.keepIf l (\e -> Bool.not (p e))
let keep_predicate = Closure(ClosureData {
function_type: t_keep_predicate,
closure_type: var_store.fresh(),
return_type: Variable::BOOL,
name: Symbol::LIST_DROP_IF_PREDICATE,
recursive: Recursive::NotRecursive,
captured_symbols: vec![(sym_predicate, t_predicate)],
arguments: vec![(
t_elem,
AnnotatedMark::new(var_store),
no_region(Pattern::Identifier(Symbol::ARG_3)),
)],
loc_body: {
let should_drop = Call(
Box::new((
t_predicate,
no_region(Var(sym_predicate)),
var_store.fresh(),
Variable::BOOL,
)),
vec![(t_elem, no_region(Var(Symbol::ARG_3)))],
CalledVia::Space,
);
Box::new(no_region(RunLowLevel {
op: LowLevel::Not,
args: vec![(Variable::BOOL, should_drop)],
ret_var: Variable::BOOL,
}))
},
});
let body = RunLowLevel {
op: LowLevel::ListKeepIf,
args: vec![(t_list, Var(sym_list)), (t_keep_predicate, keep_predicate)],
ret_var: t_list,
};
defn(
symbol,
vec![(t_list, sym_list), (t_predicate, sym_predicate)],
var_store,
body,
t_list,
)
}
/// List.dropLast: List elem -> List elem
fn list_drop_last(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let index_var = var_store.fresh();
let arg_var = var_store.fresh();
let len_var = Variable::NAT;
let num_var = len_var;
let num_precision_var = Variable::NATURAL;
let body = RunLowLevel {
op: LowLevel::ListDropAt,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(
index_var,
// Num.sub (List.len list) 1
RunLowLevel {
op: LowLevel::NumSubWrap,
args: vec![
(
arg_var,
// List.len list
RunLowLevel {
op: LowLevel::ListLen,
args: vec![(list_var, Var(Symbol::ARG_1))],
ret_var: len_var,
},
),
(
arg_var,
int::<i128>(num_var, num_precision_var, 1, int_no_bound()),
),
],
ret_var: len_var,
},
),
],
ret_var: list_var,
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
list_var,
)
}
/// List.append : List elem, elem -> List elem
fn list_append(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
@ -3166,359 +2846,6 @@ fn list_join_map(symbol: Symbol, var_store: &mut VarStore) -> Def {
)
}
// min : List (Num a) -> Result (Num a) [ListWasEmpty]*
fn list_min(symbol: Symbol, var_store: &mut VarStore) -> Def {
let arg_var = var_store.fresh();
let bool_var = var_store.fresh();
let list_var = var_store.fresh();
let len_var = Variable::NAT;
let num_var = len_var;
let num_precision_var = Variable::NATURAL;
let list_elem_var = var_store.fresh();
let ret_var = var_store.fresh();
let closure_var = var_store.fresh();
// Perform a bounds check. If it passes, delegate to List.getUnsafe.
let body = If {
cond_var: bool_var,
branch_var: var_store.fresh(),
branches: vec![(
// if-condition
no_region(
// List.len list != 0
RunLowLevel {
op: LowLevel::NotEq,
args: vec![
(
len_var,
int::<i128>(num_var, num_precision_var, 0, int_no_bound()),
),
(
len_var,
RunLowLevel {
op: LowLevel::ListLen,
args: vec![(list_var, Var(Symbol::ARG_1))],
ret_var: len_var,
},
),
],
ret_var: bool_var,
},
),
// list was not empty
no_region(
// Ok ( List.walk list (List.getUnsafe list 0) \acc,elem -> if elem < acc then elem else acc )
tag(
"Ok",
vec![
// List.walk list (List.getUnsafe list 0) \acc,elem -> if elem < acc then elem else acc
RunLowLevel {
op: LowLevel::ListWalk,
args: vec![
(list_var, Var(Symbol::ARG_1)),
// (List.getUnsafe list 0)
(
list_elem_var,
RunLowLevel {
op: LowLevel::ListGetUnsafe,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(
arg_var,
int::<i128>(
num_var,
num_precision_var,
0,
int_no_bound(),
),
),
],
ret_var: list_elem_var,
},
),
// \acc,elem -> if elem < acc then elem else acc
(closure_var, list_min_lt(list_elem_var, var_store)),
],
ret_var: list_elem_var,
},
],
var_store,
),
),
)],
final_else: Box::new(
// list was empty
no_region(
// Err ListWasEmpty
tag(
"Err",
vec![tag("ListWasEmpty", Vec::new(), var_store)],
var_store,
),
),
),
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
ret_var,
)
}
// \acc,elem -> if elem < acc then elem else acc
fn list_min_lt(list_elem_var: Variable, var_store: &mut VarStore) -> Expr {
let bool_var = var_store.fresh();
// if elem < acc then elem else acc
let body = If {
cond_var: bool_var,
branch_var: list_elem_var,
branches: vec![(
// if-condition
no_region(
// elem < acc
RunLowLevel {
op: LowLevel::NumLt,
args: vec![
(list_elem_var, Var(Symbol::ARG_4)),
(list_elem_var, Var(Symbol::ARG_3)),
],
ret_var: bool_var,
},
),
// return elem
no_region(Var(Symbol::ARG_4)),
)],
// return acc
final_else: Box::new(no_region(Var(Symbol::ARG_3))),
};
defn_help(
Symbol::LIST_MIN_LT,
vec![
(list_elem_var, Symbol::ARG_3),
(list_elem_var, Symbol::ARG_4),
],
var_store,
body,
list_elem_var,
)
}
// max : List (Num a) -> Result (Num a) [ListWasEmpty]*
fn list_max(symbol: Symbol, var_store: &mut VarStore) -> Def {
let arg_var = var_store.fresh();
let bool_var = var_store.fresh();
let list_var = var_store.fresh();
let len_var = Variable::NAT;
let num_var = len_var;
let num_precision_var = Variable::NATURAL;
let list_elem_var = var_store.fresh();
let ret_var = var_store.fresh();
let closure_var = var_store.fresh();
// Perform a bounds check. If it passes, delegate to List.getUnsafe.
let body = If {
cond_var: bool_var,
branch_var: var_store.fresh(),
branches: vec![(
// if-condition
no_region(
// List.len list != 0
RunLowLevel {
op: LowLevel::NotEq,
args: vec![
(
len_var,
int::<i128>(num_var, num_precision_var, 0, int_no_bound()),
),
(
len_var,
RunLowLevel {
op: LowLevel::ListLen,
args: vec![(list_var, Var(Symbol::ARG_1))],
ret_var: len_var,
},
),
],
ret_var: bool_var,
},
),
// list was not empty
no_region(
// Ok ( List.walk list (List.getUnsafe list 0) \acc,elem -> if elem < acc then elem else acc )
tag(
"Ok",
vec![
// List.walk list (List.getUnsafe list 0) \acc,elem -> if elem < acc then elem else acc
RunLowLevel {
op: LowLevel::ListWalk,
args: vec![
(list_var, Var(Symbol::ARG_1)),
// (List.getUnsafe list 0)
(
list_elem_var,
RunLowLevel {
op: LowLevel::ListGetUnsafe,
args: vec![
(list_var, Var(Symbol::ARG_1)),
(
arg_var,
int::<i128>(
num_var,
num_precision_var,
0,
int_no_bound(),
),
),
],
ret_var: list_elem_var,
},
),
// \acc,elem -> if elem < acc then elem else acc
(closure_var, list_max_gt(list_elem_var, var_store)),
],
ret_var: list_elem_var,
},
],
var_store,
),
),
)],
final_else: Box::new(
// list was empty
no_region(
// Err ListWasEmpty
tag(
"Err",
vec![tag("ListWasEmpty", Vec::new(), var_store)],
var_store,
),
),
),
};
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
ret_var,
)
}
// \acc,elem -> if elem > acc then elem else acc
fn list_max_gt(list_elem_var: Variable, var_store: &mut VarStore) -> Expr {
let bool_var = var_store.fresh();
// if elem > acc then elem else acc
let body = If {
cond_var: bool_var,
branch_var: list_elem_var,
branches: vec![(
// if-condition
no_region(
// elem > acc
RunLowLevel {
op: LowLevel::NumGt,
args: vec![
(list_elem_var, Var(Symbol::ARG_4)),
(list_elem_var, Var(Symbol::ARG_3)),
],
ret_var: bool_var,
},
),
// return elem
no_region(Var(Symbol::ARG_4)),
)],
// return acc
final_else: Box::new(no_region(Var(Symbol::ARG_3))),
};
defn_help(
Symbol::LIST_MAX_GT,
vec![
(list_elem_var, Symbol::ARG_3),
(list_elem_var, Symbol::ARG_4),
],
var_store,
body,
list_elem_var,
)
}
/// List.sum : List (Num a) -> Num a
fn list_sum(symbol: Symbol, var_store: &mut VarStore) -> Def {
let num_var = var_store.fresh();
let ret_var = num_var;
let list_var = var_store.fresh();
let closure_var = var_store.fresh();
let function = (
var_store.fresh(),
Loc::at_zero(Expr::Var(Symbol::LIST_WALK)),
var_store.fresh(),
ret_var,
);
let body = Expr::Call(
Box::new(function),
vec![
(list_var, Loc::at_zero(Var(Symbol::ARG_1))),
(
num_var,
Loc::at_zero(num(var_store.fresh(), 0, num_no_bound())),
),
(closure_var, Loc::at_zero(Var(Symbol::NUM_ADD))),
],
CalledVia::Space,
);
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
ret_var,
)
}
/// List.product : List (Num a) -> Num a
fn list_product(symbol: Symbol, var_store: &mut VarStore) -> Def {
let num_var = var_store.fresh();
let list_var = var_store.fresh();
let closure_var = var_store.fresh();
let function = (
var_store.fresh(),
Loc::at_zero(Expr::Var(Symbol::LIST_WALK)),
var_store.fresh(),
num_var,
);
let body = Expr::Call(
Box::new(function),
vec![
(list_var, Loc::at_zero(Var(Symbol::ARG_1))),
(
num_var,
Loc::at_zero(num(var_store.fresh(), 1, num_no_bound())),
),
(closure_var, Loc::at_zero(Var(Symbol::NUM_MUL))),
],
CalledVia::Space,
);
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
num_var,
)
}
/// List.keepIf : List elem, (elem -> Bool) -> List elem
fn list_keep_if(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
@ -3592,98 +2919,6 @@ fn list_sort_with(symbol: Symbol, var_store: &mut VarStore) -> Def {
lowlevel_2(symbol, LowLevel::ListSortWith, var_store)
}
/// List.sortAsc : List (Num a) -> List (Num a)
fn list_sort_asc(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let closure_var = var_store.fresh();
let ret_var = list_var;
let function = (
var_store.fresh(),
Loc::at_zero(Expr::Var(Symbol::LIST_SORT_WITH)),
var_store.fresh(),
ret_var,
);
let body = Expr::Call(
Box::new(function),
vec![
(list_var, Loc::at_zero(Var(Symbol::ARG_1))),
(closure_var, Loc::at_zero(Var(Symbol::NUM_COMPARE))),
],
CalledVia::Space,
);
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
ret_var,
)
}
/// List.sortDesc : List (Num a) -> List (Num a)
fn list_sort_desc(symbol: Symbol, var_store: &mut VarStore) -> Def {
let list_var = var_store.fresh();
let num_var = var_store.fresh();
let closure_var = var_store.fresh();
let compare_ret_var = var_store.fresh();
let ret_var = list_var;
let closure = Closure(ClosureData {
function_type: closure_var,
closure_type: var_store.fresh(),
return_type: compare_ret_var,
name: Symbol::LIST_SORT_DESC_COMPARE,
recursive: Recursive::NotRecursive,
captured_symbols: vec![],
arguments: vec![
(
num_var,
AnnotatedMark::new(var_store),
no_region(Pattern::Identifier(Symbol::ARG_2)),
),
(
num_var,
AnnotatedMark::new(var_store),
no_region(Pattern::Identifier(Symbol::ARG_3)),
),
],
loc_body: {
Box::new(no_region(RunLowLevel {
op: LowLevel::NumCompare,
args: vec![(num_var, Var(Symbol::ARG_3)), (num_var, Var(Symbol::ARG_2))],
ret_var: compare_ret_var,
}))
},
});
let function = (
var_store.fresh(),
Loc::at_zero(Expr::Var(Symbol::LIST_SORT_WITH)),
var_store.fresh(),
ret_var,
);
let body = Expr::Call(
Box::new(function),
vec![
(list_var, Loc::at_zero(Var(Symbol::ARG_1))),
(closure_var, Loc::at_zero(closure)),
],
CalledVia::Space,
);
defn(
symbol,
vec![(list_var, Symbol::ARG_1)],
var_store,
body,
ret_var,
)
}
/// List.any: List elem, (elem -> Bool) -> Bool
fn list_any(symbol: Symbol, var_store: &mut VarStore) -> Def {
lowlevel_2(symbol, LowLevel::ListAny, var_store)