mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-22 08:17:40 +03:00
import Result.withDefault succesfully
This commit is contained in:
parent
07d9186c98
commit
996ab744e2
@ -2,6 +2,7 @@ use crate::can::def::{canonicalize_defs, sort_can_defs, Declaration};
|
|||||||
use crate::can::env::Env;
|
use crate::can::env::Env;
|
||||||
use crate::can::expr::Output;
|
use crate::can::expr::Output;
|
||||||
use crate::can::ident::Ident;
|
use crate::can::ident::Ident;
|
||||||
|
use crate::can::ident::Lowercase;
|
||||||
use crate::can::operator::desugar_def;
|
use crate::can::operator::desugar_def;
|
||||||
use crate::can::pattern::PatternType;
|
use crate::can::pattern::PatternType;
|
||||||
use crate::can::problem::RuntimeError;
|
use crate::can::problem::RuntimeError;
|
||||||
@ -17,6 +18,7 @@ use bumpalo::Bump;
|
|||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct ModuleOutput {
|
pub struct ModuleOutput {
|
||||||
pub aliases: MutMap<Symbol, Alias>,
|
pub aliases: MutMap<Symbol, Alias>,
|
||||||
|
pub rigid_variables: MutMap<Variable, Lowercase>,
|
||||||
pub declarations: Vec<Declaration>,
|
pub declarations: Vec<Declaration>,
|
||||||
pub exposed_imports: MutMap<Symbol, Variable>,
|
pub exposed_imports: MutMap<Symbol, Variable>,
|
||||||
pub lookups: Vec<(Symbol, Variable, Region)>,
|
pub lookups: Vec<(Symbol, Variable, Region)>,
|
||||||
@ -61,6 +63,7 @@ pub fn canonicalize_module_defs<'a>(
|
|||||||
|
|
||||||
let mut env = Env::new(home, dep_idents, module_ids, exposed_ident_ids);
|
let mut env = Env::new(home, dep_idents, module_ids, exposed_ident_ids);
|
||||||
let mut lookups = Vec::with_capacity(num_deps);
|
let mut lookups = Vec::with_capacity(num_deps);
|
||||||
|
let mut rigid_variables = MutMap::default();
|
||||||
|
|
||||||
// Exposed values are treated like defs that appear before any others, e.g.
|
// Exposed values are treated like defs that appear before any others, e.g.
|
||||||
//
|
//
|
||||||
@ -109,6 +112,10 @@ pub fn canonicalize_module_defs<'a>(
|
|||||||
PatternType::TopLevelDef,
|
PatternType::TopLevelDef,
|
||||||
);
|
);
|
||||||
|
|
||||||
|
for (var, lowercase) in output.rigids.clone() {
|
||||||
|
rigid_variables.insert(var, lowercase);
|
||||||
|
}
|
||||||
|
|
||||||
let mut references = MutSet::default();
|
let mut references = MutSet::default();
|
||||||
|
|
||||||
// Gather up all the symbols that were referenced across all the defs.
|
// Gather up all the symbols that were referenced across all the defs.
|
||||||
@ -190,6 +197,7 @@ pub fn canonicalize_module_defs<'a>(
|
|||||||
|
|
||||||
Ok(ModuleOutput {
|
Ok(ModuleOutput {
|
||||||
aliases,
|
aliases,
|
||||||
|
rigid_variables,
|
||||||
declarations,
|
declarations,
|
||||||
references,
|
references,
|
||||||
exposed_imports: can_exposed_imports,
|
exposed_imports: can_exposed_imports,
|
||||||
|
@ -1,5 +1,6 @@
|
|||||||
use crate::can::def::Declaration;
|
use crate::can::def::Declaration;
|
||||||
use crate::collections::SendMap;
|
use crate::can::ident::Lowercase;
|
||||||
|
use crate::collections::{ImMap, MutMap, SendMap};
|
||||||
use crate::constrain::expr::constrain_decls;
|
use crate::constrain::expr::constrain_decls;
|
||||||
use crate::module::symbol::{ModuleId, Symbol};
|
use crate::module::symbol::{ModuleId, Symbol};
|
||||||
use crate::region::{Located, Region};
|
use crate::region::{Located, Region};
|
||||||
@ -25,22 +26,33 @@ pub struct Import<'a> {
|
|||||||
|
|
||||||
pub fn constrain_imported_values(
|
pub fn constrain_imported_values(
|
||||||
imports: Vec<Import<'_>>,
|
imports: Vec<Import<'_>>,
|
||||||
|
aliases: MutMap<Symbol, Alias>,
|
||||||
mut body_con: Constraint,
|
mut body_con: Constraint,
|
||||||
var_store: &VarStore,
|
var_store: &VarStore,
|
||||||
) -> Constraint {
|
) -> Constraint {
|
||||||
dbg!(&imports);
|
|
||||||
// TODO try out combining all the def_types and free_vars, so that we
|
// TODO try out combining all the def_types and free_vars, so that we
|
||||||
// don't need to make this big linked list of nested constraints.
|
// don't need to make this big linked list of nested constraints.
|
||||||
// Theoretically that should be equivalent to doing it this way!
|
// Theoretically that should be equivalent to doing it this way!
|
||||||
for import in imports {
|
for import in imports {
|
||||||
body_con =
|
body_con = constrain_imported_value(
|
||||||
constrain_imported_value(import.loc_symbol, import.solved_type, body_con, var_store);
|
import.loc_symbol,
|
||||||
|
import.solved_type,
|
||||||
|
body_con,
|
||||||
|
&aliases,
|
||||||
|
var_store,
|
||||||
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
body_con
|
body_con
|
||||||
}
|
}
|
||||||
|
|
||||||
fn to_type(solved_type: &SolvedType, free_vars: &mut Vec<Variable>, var_store: &VarStore) -> Type {
|
#[derive(Debug, Clone, Default)]
|
||||||
|
pub struct FreeVars {
|
||||||
|
rigid_vars: ImMap<Lowercase, Variable>,
|
||||||
|
flex_vars: Vec<Variable>,
|
||||||
|
}
|
||||||
|
|
||||||
|
fn to_type(solved_type: &SolvedType, free_vars: &mut FreeVars, var_store: &VarStore) -> Type {
|
||||||
use crate::solve::SolvedType::*;
|
use crate::solve::SolvedType::*;
|
||||||
|
|
||||||
match solved_type {
|
match solved_type {
|
||||||
@ -64,16 +76,19 @@ fn to_type(solved_type: &SolvedType, free_vars: &mut Vec<Variable>, var_store: &
|
|||||||
|
|
||||||
Type::Apply(*symbol, new_args)
|
Type::Apply(*symbol, new_args)
|
||||||
}
|
}
|
||||||
Rigid(symbol) => {
|
Rigid(lowercase) => {
|
||||||
// TODO: I guess the design here is that we need to record
|
if let Some(var) = free_vars.rigid_vars.get(&lowercase) {
|
||||||
// rigids after all, and incorporate them into
|
Type::Variable(*var)
|
||||||
// the final constraint? Just to make sure the types
|
} else {
|
||||||
// actually line up? Should take a look at how
|
let var = var_store.fresh();
|
||||||
// this is done in the Defs annotations.
|
free_vars.rigid_vars.insert(lowercase.clone(), var);
|
||||||
panic!("TODO to_type for a rigid: {:?}", symbol);
|
Type::Variable(var)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
Wildcard => {
|
Wildcard => {
|
||||||
panic!("TODO flex variable for wildcard");
|
let var = var_store.fresh();
|
||||||
|
free_vars.flex_vars.push(var);
|
||||||
|
Type::Variable(var)
|
||||||
}
|
}
|
||||||
Record { fields, ext } => {
|
Record { fields, ext } => {
|
||||||
let mut new_fields = SendMap::default();
|
let mut new_fields = SendMap::default();
|
||||||
@ -127,41 +142,20 @@ fn constrain_imported_value(
|
|||||||
loc_symbol: Located<Symbol>,
|
loc_symbol: Located<Symbol>,
|
||||||
solved_type: &SolvedType,
|
solved_type: &SolvedType,
|
||||||
body_con: Constraint,
|
body_con: Constraint,
|
||||||
|
aliases: &MutMap<Symbol, Alias>,
|
||||||
var_store: &VarStore,
|
var_store: &VarStore,
|
||||||
) -> Constraint {
|
) -> Constraint {
|
||||||
use Constraint::*;
|
use Constraint::*;
|
||||||
let mut free_vars = Vec::new();
|
let mut free_vars = FreeVars::default();
|
||||||
|
|
||||||
// an imported symbol can be both an alias and a value
|
// an imported symbol can be both an alias and a value
|
||||||
match solved_type {
|
match solved_type {
|
||||||
SolvedType::Alias(symbol, args, solved_actual) if symbol == &loc_symbol.value => {
|
SolvedType::Alias(symbol, _, _) if symbol == &loc_symbol.value => {
|
||||||
let mut def_aliases = SendMap::default();
|
if let Some(alias) = aliases.get(symbol) {
|
||||||
|
constrain_imported_alias(loc_symbol, alias, body_con, var_store)
|
||||||
let actual = to_type(solved_actual, &mut free_vars, var_store);
|
} else {
|
||||||
|
panic!("Alias {:?} is not available", symbol)
|
||||||
// pub vars: Vec<Located<(Lowercase, Variable)>>,
|
}
|
||||||
let vars = Vec::new();
|
|
||||||
|
|
||||||
let alias = Alias {
|
|
||||||
region: loc_symbol.region,
|
|
||||||
vars,
|
|
||||||
typ: actual,
|
|
||||||
};
|
|
||||||
|
|
||||||
def_aliases.insert(*symbol, alias);
|
|
||||||
|
|
||||||
Let(Box::new(LetConstraint {
|
|
||||||
// rigids from other modules should not be treated as rigid
|
|
||||||
// within this module; rather, they should be treated as flex
|
|
||||||
rigid_vars: Vec::new(),
|
|
||||||
flex_vars: Vec::new(),
|
|
||||||
// Importing a value doesn't constrain this module at all.
|
|
||||||
// All it does is introduce variables and provide def_types for lookups
|
|
||||||
def_types: SendMap::default(),
|
|
||||||
def_aliases,
|
|
||||||
defs_constraint: True,
|
|
||||||
ret_constraint: body_con,
|
|
||||||
}))
|
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
let mut def_types = SendMap::default();
|
let mut def_types = SendMap::default();
|
||||||
@ -175,11 +169,17 @@ fn constrain_imported_value(
|
|||||||
},
|
},
|
||||||
);
|
);
|
||||||
|
|
||||||
|
let mut rigid_vars = Vec::new();
|
||||||
|
|
||||||
|
for (_, var) in free_vars.rigid_vars {
|
||||||
|
rigid_vars.push(var);
|
||||||
|
}
|
||||||
|
|
||||||
Let(Box::new(LetConstraint {
|
Let(Box::new(LetConstraint {
|
||||||
// rigids from other modules should not be treated as rigid
|
// rigids from other modules should not be treated as rigid
|
||||||
// within this module; rather, they should be treated as flex
|
// within this module; rather, they should be treated as flex
|
||||||
rigid_vars: Vec::new(),
|
rigid_vars,
|
||||||
flex_vars: free_vars,
|
flex_vars: Vec::new(),
|
||||||
// Importing a value doesn't constrain this module at all.
|
// Importing a value doesn't constrain this module at all.
|
||||||
// All it does is introduce variables and provide def_types for lookups
|
// All it does is introduce variables and provide def_types for lookups
|
||||||
def_types,
|
def_types,
|
||||||
@ -190,3 +190,49 @@ fn constrain_imported_value(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn constrain_imported_alias(
|
||||||
|
loc_symbol: Located<Symbol>,
|
||||||
|
imported_alias: &Alias,
|
||||||
|
body_con: Constraint,
|
||||||
|
var_store: &VarStore,
|
||||||
|
) -> Constraint {
|
||||||
|
use Constraint::*;
|
||||||
|
let mut def_aliases = SendMap::default();
|
||||||
|
|
||||||
|
let mut vars = Vec::with_capacity(imported_alias.vars.len());
|
||||||
|
let mut substitution = ImMap::default();
|
||||||
|
for Located {
|
||||||
|
region,
|
||||||
|
value: (lowercase, old_var),
|
||||||
|
} in &imported_alias.vars
|
||||||
|
{
|
||||||
|
let new_var = var_store.fresh();
|
||||||
|
vars.push(Located::at(*region, (lowercase.clone(), new_var)));
|
||||||
|
substitution.insert(*old_var, Type::Variable(new_var));
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut actual = imported_alias.typ.clone();
|
||||||
|
actual.substitute(&substitution);
|
||||||
|
|
||||||
|
let alias = Alias {
|
||||||
|
vars,
|
||||||
|
region: loc_symbol.region,
|
||||||
|
typ: actual,
|
||||||
|
};
|
||||||
|
|
||||||
|
def_aliases.insert(loc_symbol.value, alias);
|
||||||
|
|
||||||
|
Let(Box::new(LetConstraint {
|
||||||
|
// rigids from other modules should not be treated as rigid
|
||||||
|
// within this module; rather, they should be treated as flex
|
||||||
|
rigid_vars: Vec::new(),
|
||||||
|
flex_vars: Vec::new(),
|
||||||
|
// Importing a value doesn't constrain this module at all.
|
||||||
|
// All it does is introduce variables and provide def_types for lookups
|
||||||
|
def_types: SendMap::default(),
|
||||||
|
def_aliases,
|
||||||
|
defs_constraint: True,
|
||||||
|
ret_constraint: body_con,
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
@ -311,7 +311,7 @@ impl<S: UnificationStore> UnificationTable<S> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_redirect(&mut self, vid: S::Key) -> bool {
|
pub fn is_redirect(&self, vid: S::Key) -> bool {
|
||||||
self.value(vid).raw_parent() != vid
|
self.value(vid).raw_parent() != vid
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
use crate::can::def::Declaration;
|
use crate::can::def::Declaration;
|
||||||
use crate::can::ident::{Ident, ModuleName};
|
use crate::can::ident::{Ident, Lowercase, ModuleName};
|
||||||
use crate::can::module::{canonicalize_module_defs, ModuleOutput};
|
use crate::can::module::{canonicalize_module_defs, ModuleOutput};
|
||||||
use crate::collections::{default_hasher, insert_all, MutMap, MutSet, SendMap};
|
use crate::collections::{default_hasher, insert_all, MutMap, MutSet, SendMap};
|
||||||
use crate::constrain::module::{constrain_imported_values, constrain_module, Import};
|
use crate::constrain::module::{constrain_imported_values, constrain_module, Import};
|
||||||
@ -34,6 +34,7 @@ pub struct Module {
|
|||||||
pub exposed_vars_by_symbol: Vec<(Symbol, Variable)>,
|
pub exposed_vars_by_symbol: Vec<(Symbol, Variable)>,
|
||||||
pub references: MutSet<Symbol>,
|
pub references: MutSet<Symbol>,
|
||||||
pub aliases: MutMap<Symbol, Alias>,
|
pub aliases: MutMap<Symbol, Alias>,
|
||||||
|
pub rigid_variables: MutMap<Variable, Lowercase>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct LoadedModule {
|
pub struct LoadedModule {
|
||||||
@ -77,6 +78,7 @@ enum Msg {
|
|||||||
Solved {
|
Solved {
|
||||||
module_id: ModuleId,
|
module_id: ModuleId,
|
||||||
solved_types: MutMap<Symbol, SolvedType>,
|
solved_types: MutMap<Symbol, SolvedType>,
|
||||||
|
aliases: MutMap<Symbol, Alias>,
|
||||||
subs: Arc<Solved<Subs>>,
|
subs: Arc<Solved<Subs>>,
|
||||||
problems: Vec<Problem>,
|
problems: Vec<Problem>,
|
||||||
},
|
},
|
||||||
@ -372,6 +374,7 @@ pub async fn load<'a>(
|
|||||||
solved_types,
|
solved_types,
|
||||||
subs,
|
subs,
|
||||||
problems,
|
problems,
|
||||||
|
aliases,
|
||||||
..
|
..
|
||||||
} => {
|
} => {
|
||||||
all_problems.extend(problems);
|
all_problems.extend(problems);
|
||||||
@ -410,7 +413,8 @@ pub async fn load<'a>(
|
|||||||
} else {
|
} else {
|
||||||
// This was a dependency. Write it down and keep processing messages.
|
// This was a dependency. Write it down and keep processing messages.
|
||||||
debug_assert!(!exposed_types.contains_key(&module_id));
|
debug_assert!(!exposed_types.contains_key(&module_id));
|
||||||
exposed_types.insert(module_id, ExposedModuleTypes::Valid(solved_types));
|
exposed_types
|
||||||
|
.insert(module_id, ExposedModuleTypes::Valid(solved_types, aliases));
|
||||||
|
|
||||||
// Notify all the listeners that this solved.
|
// Notify all the listeners that this solved.
|
||||||
if let Some(listeners) = solve_listeners.remove(&module_id) {
|
if let Some(listeners) = solve_listeners.remove(&module_id) {
|
||||||
@ -707,6 +711,7 @@ fn solve_module(
|
|||||||
) {
|
) {
|
||||||
let home = module.module_id;
|
let home = module.module_id;
|
||||||
let mut imports = Vec::with_capacity(module.references.len());
|
let mut imports = Vec::with_capacity(module.references.len());
|
||||||
|
let mut aliases = MutMap::default();
|
||||||
|
|
||||||
// Translate referenced symbols into constraints
|
// Translate referenced symbols into constraints
|
||||||
for &symbol in module.references.iter() {
|
for &symbol in module.references.iter() {
|
||||||
@ -721,7 +726,7 @@ fn solve_module(
|
|||||||
};
|
};
|
||||||
|
|
||||||
match exposed_types.get(&module_id) {
|
match exposed_types.get(&module_id) {
|
||||||
Some(ExposedModuleTypes::Valid(solved_types)) => {
|
Some(ExposedModuleTypes::Valid(solved_types, new_aliases)) => {
|
||||||
let solved_type = solved_types.get(&loc_symbol.value).unwrap_or_else(|| {
|
let solved_type = solved_types.get(&loc_symbol.value).unwrap_or_else(|| {
|
||||||
panic!(
|
panic!(
|
||||||
"Could not find {:?} in solved_types {:?}",
|
"Could not find {:?} in solved_types {:?}",
|
||||||
@ -729,6 +734,11 @@ fn solve_module(
|
|||||||
)
|
)
|
||||||
});
|
});
|
||||||
|
|
||||||
|
// TODO should this be a union?
|
||||||
|
for (k, v) in new_aliases.clone() {
|
||||||
|
aliases.insert(k, v);
|
||||||
|
}
|
||||||
|
|
||||||
imports.push(Import {
|
imports.push(Import {
|
||||||
loc_symbol,
|
loc_symbol,
|
||||||
solved_type,
|
solved_type,
|
||||||
@ -753,7 +763,7 @@ fn solve_module(
|
|||||||
}
|
}
|
||||||
|
|
||||||
// Wrap the existing module constraint in these imported constraints.
|
// Wrap the existing module constraint in these imported constraints.
|
||||||
let constraint = constrain_imported_values(imports, constraint, &var_store);
|
let constraint = constrain_imported_values(imports, aliases, constraint, &var_store);
|
||||||
|
|
||||||
// All the exposed imports should be available in the solver's vars_by_symbol
|
// All the exposed imports should be available in the solver's vars_by_symbol
|
||||||
for (symbol, expr_var) in module.exposed_imports.iter() {
|
for (symbol, expr_var) in module.exposed_imports.iter() {
|
||||||
@ -787,18 +797,22 @@ fn solve_module(
|
|||||||
aliases.insert(symbol, alias);
|
aliases.insert(symbol, alias);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
let env = solve::Env {
|
||||||
|
vars_by_symbol,
|
||||||
|
aliases: aliases.clone(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut subs = Subs::new(var_store.into());
|
||||||
|
for (var, name) in module.rigid_variables {
|
||||||
|
subs.rigid_var(var, name);
|
||||||
|
}
|
||||||
|
|
||||||
// Start solving this module in the background.
|
// Start solving this module in the background.
|
||||||
spawn_blocking(move || {
|
spawn_blocking(move || {
|
||||||
// Now that the module is parsed, canonicalized, and constrained,
|
// Now that the module is parsed, canonicalized, and constrained,
|
||||||
// we need to type check it.
|
// we need to type check it.
|
||||||
let subs = Subs::new(var_store.into());
|
|
||||||
let mut problems = Vec::new();
|
let mut problems = Vec::new();
|
||||||
|
|
||||||
let env = solve::Env {
|
|
||||||
vars_by_symbol,
|
|
||||||
aliases,
|
|
||||||
};
|
|
||||||
|
|
||||||
// Run the solver to populate Subs.
|
// Run the solver to populate Subs.
|
||||||
let (solved_subs, solved_env) = solve::run(&env, &mut problems, subs, &constraint);
|
let (solved_subs, solved_env) = solve::run(&env, &mut problems, subs, &constraint);
|
||||||
|
|
||||||
@ -842,6 +856,7 @@ fn solve_module(
|
|||||||
subs: Arc::new(solved_subs),
|
subs: Arc::new(solved_subs),
|
||||||
solved_types,
|
solved_types,
|
||||||
problems,
|
problems,
|
||||||
|
aliases: aliases.clone().into_iter().collect(),
|
||||||
})
|
})
|
||||||
.await
|
.await
|
||||||
.unwrap_or_else(|_| panic!("Failed to send Solved message"));
|
.unwrap_or_else(|_| panic!("Failed to send Solved message"));
|
||||||
@ -944,6 +959,7 @@ fn parse_and_constrain(
|
|||||||
exposed_vars_by_symbol,
|
exposed_vars_by_symbol,
|
||||||
references,
|
references,
|
||||||
aliases,
|
aliases,
|
||||||
|
rigid_variables,
|
||||||
..
|
..
|
||||||
}) => {
|
}) => {
|
||||||
let constraint = constrain_module(module_id, &declarations, lookups);
|
let constraint = constrain_module(module_id, &declarations, lookups);
|
||||||
@ -955,6 +971,7 @@ fn parse_and_constrain(
|
|||||||
exposed_vars_by_symbol,
|
exposed_vars_by_symbol,
|
||||||
references,
|
references,
|
||||||
aliases,
|
aliases,
|
||||||
|
rigid_variables,
|
||||||
};
|
};
|
||||||
|
|
||||||
(module, ident_ids, constraint)
|
(module, ident_ids, constraint)
|
||||||
|
19
src/solve.rs
19
src/solve.rs
@ -19,7 +19,7 @@ pub type SubsByModule = MutMap<ModuleId, ExposedModuleTypes>;
|
|||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub enum ExposedModuleTypes {
|
pub enum ExposedModuleTypes {
|
||||||
Invalid,
|
Invalid,
|
||||||
Valid(MutMap<Symbol, SolvedType>),
|
Valid(MutMap<Symbol, SolvedType>, MutMap<Symbol, Alias>),
|
||||||
}
|
}
|
||||||
|
|
||||||
/// This is a fully solved type, with no Variables remaining in it.
|
/// This is a fully solved type, with no Variables remaining in it.
|
||||||
@ -139,8 +139,9 @@ impl SolvedType {
|
|||||||
SolvedType::Alias(symbol, solved_args, Box::new(solved_type))
|
SolvedType::Alias(symbol, solved_args, Box::new(solved_type))
|
||||||
}
|
}
|
||||||
Boolean(val) => SolvedType::Boolean(val),
|
Boolean(val) => SolvedType::Boolean(val),
|
||||||
Variable(_var) => {
|
Variable(var) => {
|
||||||
panic!("TODO handle translate variable to SolvedType (wildcard or rigid)");
|
let content = solved_subs.inner().get_without_compacting(var).content;
|
||||||
|
Self::from_content(solved_subs.inner(), content)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -149,16 +150,17 @@ impl SolvedType {
|
|||||||
use crate::subs::Content::*;
|
use crate::subs::Content::*;
|
||||||
|
|
||||||
match content {
|
match content {
|
||||||
FlexVar(_) => SolvedType::Wildcard,
|
FlexVar(None) => SolvedType::Wildcard,
|
||||||
|
FlexVar(Some(name)) => SolvedType::Rigid(name),
|
||||||
RigidVar(name) => SolvedType::Rigid(name),
|
RigidVar(name) => SolvedType::Rigid(name),
|
||||||
Structure(flat_type) => Self::from_flat_type(subs, flat_type),
|
Structure(flat_type) => Self::from_flat_type(subs, flat_type),
|
||||||
Alias(symbol, args, var) => {
|
Alias(symbol, args, var) => {
|
||||||
let mut new_args = Vec::with_capacity(args.len());
|
let mut new_args = Vec::with_capacity(args.len());
|
||||||
|
|
||||||
for (arg_name, _arg_var) in args {
|
for (arg_name, arg_var) in args {
|
||||||
new_args.push((
|
new_args.push((
|
||||||
arg_name,
|
arg_name,
|
||||||
Self::from_content(subs, subs.get_without_compacting(var).content),
|
Self::from_content(subs, subs.get_without_compacting(arg_var).content),
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -607,7 +609,10 @@ fn solve(
|
|||||||
debug_assert!({
|
debug_assert!({
|
||||||
let failing: Vec<_> = rigid_vars
|
let failing: Vec<_> = rigid_vars
|
||||||
.iter()
|
.iter()
|
||||||
.filter(|&var| subs.get_without_compacting(*var).rank != Rank::NONE)
|
.filter(|&var| {
|
||||||
|
!subs.redundant(*var)
|
||||||
|
&& subs.get_without_compacting(*var).rank != Rank::NONE
|
||||||
|
})
|
||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
if !failing.is_empty() {
|
if !failing.is_empty() {
|
||||||
|
@ -288,7 +288,7 @@ impl Subs {
|
|||||||
self.utable.unioned(left, right)
|
self.utable.unioned(left, right)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn redundant(&mut self, var: Variable) -> bool {
|
pub fn redundant(&self, var: Variable) -> bool {
|
||||||
self.utable.is_redirect(var)
|
self.utable.is_redirect(var)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1,6 +1,6 @@
|
|||||||
interface Primary
|
interface Primary
|
||||||
exposes [ blah, str ]
|
exposes [ blah, str ]
|
||||||
imports [ Dep1, Dep2.{ two, foo }, Dep3.Blah.{ bar } ]
|
imports [ Dep1, Dep2.{ two, foo }, Dep3.Blah.{ bar }, Result ]
|
||||||
|
|
||||||
blah = {}
|
blah = {}
|
||||||
|
|
||||||
@ -17,6 +17,24 @@ identity = \a -> a
|
|||||||
z : Dep1.Unit
|
z : Dep1.Unit
|
||||||
z = Unit
|
z = Unit
|
||||||
|
|
||||||
w : Dep1.Identity Int
|
w : Dep1.Identity {}
|
||||||
w = Identity 42
|
w = Identity {}
|
||||||
|
|
||||||
|
succeed : a -> Dep1.Identity a
|
||||||
|
succeed = \x -> Identity x
|
||||||
|
|
||||||
|
map = Result.withDefault
|
||||||
|
|
||||||
|
yay : Result.Result e {}
|
||||||
|
yay = Ok {}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# yay =
|
||||||
|
# v = Ok "foo"
|
||||||
|
#
|
||||||
|
# f = \_ -> {}
|
||||||
|
#
|
||||||
|
# v
|
||||||
|
# |> Result.map f
|
||||||
|
# |> Result.withDefault {}
|
||||||
|
23
tests/fixtures/build/interface_with_deps/Result.roc
vendored
Normal file
23
tests/fixtures/build/interface_with_deps/Result.roc
vendored
Normal file
@ -0,0 +1,23 @@
|
|||||||
|
interface Result
|
||||||
|
exposes [ Result, withDefault, map, andThen ]
|
||||||
|
imports []
|
||||||
|
|
||||||
|
Result e a : [ Ok a, Err e ]
|
||||||
|
|
||||||
|
map : Result e a, (a -> b) -> Result e b
|
||||||
|
map = \result, f ->
|
||||||
|
when result is
|
||||||
|
Ok v -> Ok (f v)
|
||||||
|
Err e -> Err e
|
||||||
|
|
||||||
|
withDefault : Result x a, a -> a
|
||||||
|
withDefault = \result, default ->
|
||||||
|
when result is
|
||||||
|
Ok v -> v
|
||||||
|
Err _ -> default
|
||||||
|
|
||||||
|
andThen : Result e a, (a -> Result e b) -> Result e b
|
||||||
|
andThen = \result, f ->
|
||||||
|
when result is
|
||||||
|
Ok v -> f v
|
||||||
|
Err e -> Err e
|
@ -159,7 +159,7 @@ mod test_load {
|
|||||||
.expect("Test ModuleID not found in module_ids");
|
.expect("Test ModuleID not found in module_ids");
|
||||||
|
|
||||||
assert_eq!(expected_name, &InlinableString::from("Primary"));
|
assert_eq!(expected_name, &InlinableString::from("Primary"));
|
||||||
assert_eq!(def_count, 5);
|
assert_eq!(def_count, 9);
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -306,7 +306,10 @@ mod test_load {
|
|||||||
"alwaysThree" => "* -> Str",
|
"alwaysThree" => "* -> Str",
|
||||||
"identity" => "a -> a",
|
"identity" => "a -> a",
|
||||||
"z" => "Dep1.Unit",
|
"z" => "Dep1.Unit",
|
||||||
"w" => "Dep1.Identity Int",
|
"w" => "Dep1.Identity {}",
|
||||||
|
"succeed" => "a -> Dep1.Identity a",
|
||||||
|
"yay" => "Result.Result e {}",
|
||||||
|
"map" => "Result.Result * a, a -> a",
|
||||||
},
|
},
|
||||||
);
|
);
|
||||||
});
|
});
|
||||||
|
Loading…
Reference in New Issue
Block a user