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

reintroduce multiple uniqueness vars in numbers

Browse source
This commit is contained in:
Folkert 2020-12-22 20:13:54 +01:00
parent 232e1aa1ee
commit caaf8e76c1
6 changed files with 47 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

63
compiler/constrain/src/uniq.rs
View file

@ -166,25 +166,25 @@ fn constrain_pattern(
}
NumLiteral(inner_var, _) => {
let (num_var, num_type) = unique_unbound_num(*inner_var, var_store);
let (inner_uvar, num_var, num_type) = unique_unbound_num(*inner_var, var_store);
state.constraints.push(exists(
vec![num_var, *inner_var],
vec![num_var, inner_uvar, *inner_var],
Constraint::Pattern(pattern.region, PatternCategory::Num, num_type, expected),
));
}
IntLiteral(_) => {
let (num_uvar, num_type) = unique_int(var_store);
let (a, b, c, num_type) = unique_int(var_store);
state.constraints.push(exists(
vec![num_uvar],
vec![a, b, c],
Constraint::Pattern(pattern.region, PatternCategory::Int, num_type, expected),
));
}
FloatLiteral(_) => {
let (num_uvar, num_type) = unique_float(var_store);
let (a, b, c, num_type) = unique_float(var_store);
state.constraints.push(exists(
vec![num_uvar],
vec![a, b, c],
Constraint::Pattern(pattern.region, PatternCategory::Float, num_type, expected),
));
}
@ -406,42 +406,47 @@ fn constrain_pattern(
}
}
fn unique_unbound_num(inner_var: Variable, var_store: &mut VarStore) -> (Variable, Type) {
let num_var = var_store.fresh();
fn unique_unbound_num(inner_var: Variable, var_store: &mut VarStore) -> (Variable, Variable, Type) {
let num_uvar = var_store.fresh();
let inner_uvar = var_store.fresh();
let val_type = Type::Variable(inner_var);
let val_utype = attr_type(Bool::variable(num_var), val_type);
let val_utype = attr_type(Bool::variable(inner_uvar), val_type);
let num_utype = num_num(val_utype);
let num_type = attr_type(Bool::variable(num_var), num_utype);
let num_type = attr_type(Bool::variable(num_uvar), num_utype);
(num_var, num_type)
(inner_uvar, num_uvar, num_type)
}
fn unique_int(var_store: &mut VarStore) -> (Variable, Type) {
let num_uvar = var_store.fresh();
fn unique_int(var_store: &mut VarStore) -> (Variable, Variable, Variable, Type) {
let num_uvar1 = var_store.fresh();
let num_uvar2 = var_store.fresh();
let num_uvar3 = var_store.fresh();
let signed_64 = num_signed64();
let attr_signed_64 = attr_type(Bool::variable(num_uvar), signed_64);
let attr_signed_64 = attr_type(Bool::variable(num_uvar1), signed_64);
let integer = num_integer(attr_signed_64);
let attr_int = attr_type(Bool::variable(num_uvar), integer);
let attr_int = attr_type(Bool::variable(num_uvar2), integer);
let num = num_num(attr_int);
let attr_num = attr_type(Bool::variable(num_uvar), num);
let attr_num = attr_type(Bool::variable(num_uvar3), num);
(num_uvar, attr_num)
(num_uvar1, num_uvar2, num_uvar3, attr_num)
}
fn unique_float(var_store: &mut VarStore) -> (Variable, Type) {
let num_uvar = var_store.fresh();
fn unique_float(var_store: &mut VarStore) -> (Variable, Variable, Variable, Type) {
let num_uvar1 = var_store.fresh();
let num_uvar2 = var_store.fresh();
let num_uvar3 = var_store.fresh();
let binary_64 = num_binary64();
let attr_binary_64 = attr_type(Bool::variable(num_uvar), binary_64);
let attr_binary_64 = attr_type(Bool::variable(num_uvar1), binary_64);
let fp = num_floatingpoint(attr_binary_64);
let attr_fp = attr_type(Bool::variable(num_uvar), fp);
let attr_fp = attr_type(Bool::variable(num_uvar2), fp);
let num = num_num(attr_fp);
let attr_num = attr_type(Bool::variable(num_uvar), num);
let attr_num = attr_type(Bool::variable(num_uvar3), num);
(num_uvar, attr_num)
(num_uvar1, num_uvar2, num_uvar3, attr_num)
}
pub fn constrain_expr(
@ -458,10 +463,10 @@ pub fn constrain_expr(
match expr {
Num(inner_var, _) => {
let var = var_store.fresh();
let (num_var, num_type) = unique_unbound_num(*inner_var, var_store);
let (inner_uvar, num_var, num_type) = unique_unbound_num(*inner_var, var_store);
exists(
vec![var, *inner_var, num_var],
vec![var, *inner_var, inner_uvar, num_var],
And(vec![
Eq(
Type::Variable(var),
@ -474,10 +479,10 @@ pub fn constrain_expr(
)
}
Int(var, _) => {
let (num_uvar, num_type) = unique_int(var_store);
let (a, b, c, num_type) = unique_int(var_store);
exists(
vec![*var, num_uvar],
vec![*var, a, b, c],
And(vec![
Eq(
Type::Variable(*var),
@ -490,10 +495,10 @@ pub fn constrain_expr(
)
}
Float(var, _) => {
let (num_uvar, num_type) = unique_float(var_store);
let (a, b, c, num_type) = unique_float(var_store);
exists(
vec![*var, num_uvar],
vec![*var, a, b, c],
And(vec![
Eq(
Type::Variable(*var),

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

@ -1136,7 +1136,7 @@ mod gen_list {
#[test]
fn set_unique_list_oob() {
assert_non_opt_evals_to!(
assert_evals_to!(
"List.set [ 3, 17, 4.1 ] 1337 9.25",
RocList::from_slice(&[3.0, 17.0, 4.1]),
RocList<f64>

4
compiler/load/tests/test_uniq_load.rs
View file

@ -236,10 +236,10 @@ mod test_uniq_load {
"divisionFn" => "Attr Shared (Attr * F64, Attr * F64 -> Attr * (Result (Attr * F64) (Attr * [ DivByZero ]*)))",
"divisionTest" => "Attr * (Result (Attr * F64) (Attr * [ DivByZero ]*))",
"intTest" => "Attr * I64",
"x" => "Attr a F64",
"x" => "Attr * F64",
"constantNum" => "Attr * (Num (Attr * *))",
"divDep1ByDep2" => "Attr * (Result (Attr * F64) (Attr * [ DivByZero ]*))",
"fromDep2" => "Attr a F64",
"fromDep2" => "Attr * F64",
},
);
}

10
compiler/reporting/tests/test_reporting.rs
View file

@ -448,8 +448,8 @@ mod test_reporting {
baz
Str
main
U8
F64
"#
),
)
@ -620,9 +620,9 @@ mod test_reporting {
these names seem close though:
Result
Num
Set
Result
U8
"#
),
@ -1374,7 +1374,7 @@ mod test_reporting {
Bool
U8
F64
Num
Str
"#
),
)
@ -2094,7 +2094,7 @@ mod test_reporting {
But `add` needs the 2nd argument to be:
Num Integer
Num (Integer Signed64)
"#
),
)
@ -2123,7 +2123,7 @@ mod test_reporting {
But `add` needs the 2nd argument to be:
Num Integer
Num (Integer Signed64)
Tip: You can convert between Int and Float using functions like
`Num.toFloat` and `Num.round`.

10
compiler/solve/tests/solve_uniq_expr.rs
View file

@ -75,7 +75,7 @@ mod solve_uniq_expr {
#[test]
fn float_literal() {
infer_eq("0.5", "Attr a F64");
infer_eq("0.5", "Attr * F64");
}
#[test]
@ -640,7 +640,7 @@ mod solve_uniq_expr {
(\a -> a) 3.14
"#
),
"Attr a F64",
"Attr * F64",
);
}
@ -1211,7 +1211,7 @@ mod solve_uniq_expr {
{ numIdentity, p, q }
"#
),
"Attr * { numIdentity : Attr Shared (Attr b (Num (Attr a p)) -> Attr b (Num (Attr a p))), p : Attr * (Num (Attr * p)), q : Attr c F64 }"
"Attr * { numIdentity : Attr Shared (Attr b (Num (Attr a p)) -> Attr b (Num (Attr a p))), p : Attr * (Num (Attr * p)), q : Attr * F64 }"
);
}
@ -3180,7 +3180,7 @@ mod solve_uniq_expr {
List.set [0x2] 1337 0
"#
),
"Attr * (List (Attr a I64))",
"Attr * (List (Attr * I64))",
);
}
@ -3192,7 +3192,7 @@ mod solve_uniq_expr {
List.set [0.2] 1337 0
"#
),
"Attr * (List (Attr a F64))",
"Attr * (List (Attr * F64))",
);
}

2
compiler/types/src/pretty_print.rs
View file

@ -77,8 +77,6 @@ fn find_names_needed(
use crate::subs::Content::*;
use crate::subs::FlatType::*;
dbg!(variable);
while let Some((recursive, _chain)) = subs.occurs(variable) {
let content = subs.get_without_compacting(recursive).content;
match content {