Print lambda sets on-demand

ast/src/constrain.rs

@@ -1938,7 +1938,7 @@ pub mod test_constrain {
     use roc_parse::parser::{SourceError, SyntaxError};
     use roc_region::all::Region;
     use roc_types::{
-        pretty_print::name_and_print_var,
+        pretty_print::{name_and_print_var, PrintLambdaSets},
         solved_types::Solved,
         subs::{Subs, VarStore, Variable},
     };
@@ -2059,7 +2059,8 @@ pub mod test_constrain {
                     all_ident_ids: dep_idents,
                 };
 
-                let actual_str = name_and_print_var(var, subs, mod_id, &interns);
+                let actual_str =
+                    name_and_print_var(var, subs, mod_id, &interns, PrintLambdaSets::No);
 
                 assert_eq!(actual_str, expected_str);
             }

compiler/load_internal/tests/test_load.rs

@@ -30,6 +30,7 @@ mod test_load {
     use roc_reporting::report::RocDocAllocator;
     use roc_target::TargetInfo;
     use roc_types::pretty_print::name_and_print_var;
+    use roc_types::pretty_print::PrintLambdaSets;
     use roc_types::subs::Subs;
     use std::collections::HashMap;
     use std::path::{Path, PathBuf};
@@ -237,7 +238,8 @@ mod test_load {
         expected_types: &mut HashMap<&str, &str>,
     ) {
         for (symbol, expr_var) in &def.pattern_vars {
-            let actual_str = name_and_print_var(*expr_var, subs, home, interns);
+            let actual_str =
+                name_and_print_var(*expr_var, subs, home, interns, PrintLambdaSets::No);
             let fully_qualified = symbol.fully_qualified(interns, home).to_string();
             let expected_type = expected_types
                 .remove(fully_qualified.as_str())

compiler/solve/tests/solve_expr.rs

@@ -19,7 +19,7 @@ mod solve_expr {
     use roc_region::all::{LineColumn, LineColumnRegion, LineInfo, Region};
     use roc_reporting::report::{can_problem, type_problem, RocDocAllocator};
     use roc_solve::solve::TypeError;
-    use roc_types::pretty_print::name_and_print_var;
+    use roc_types::pretty_print::{name_and_print_var, PrintLambdaSets};
     use std::path::PathBuf;
 
     // HELPERS
@@ -177,7 +177,7 @@ mod solve_expr {
 
         debug_assert!(exposed_to_host.len() == 1);
         let (_symbol, variable) = exposed_to_host.into_iter().next().unwrap();
-        let actual_str = name_and_print_var(variable, subs, home, &interns);
+        let actual_str = name_and_print_var(variable, subs, home, &interns, PrintLambdaSets::No);
 
         Ok((type_problems, can_problems, actual_str))
     }
@@ -277,7 +277,7 @@ mod solve_expr {
             let var = find_type_at(region, &decls)
                 .unwrap_or_else(|| panic!("No type for {} ({:?})!", &text, region));
 
-            let actual_str = name_and_print_var(var, subs, home, &interns);
+            let actual_str = name_and_print_var(var, subs, home, &interns, PrintLambdaSets::No);
 
             let elaborated = match find_ability_member_at(region, &decls) {
                 Some((member, specialization_id)) => {

compiler/types/src/pretty_print.rs

@@ -1,6 +1,6 @@
 use crate::subs::{
     self, AliasVariables, Content, FlatType, GetSubsSlice, Label, Subs, SubsIndex, UnionLabels,
-    UnionTags, Variable,
+    UnionTags, UnsortedUnionLabels, Variable,
 };
 use crate::types::{name_type_var, RecordField, Uls};
 use roc_collections::all::MutMap;
@@ -48,9 +48,15 @@ macro_rules! write_parens {
     };
 }
 
+pub enum PrintLambdaSets {
+    Yes,
+    No,
+}
+
 struct Env<'a> {
     home: ModuleId,
     interns: &'a Interns,
+    print_lambda_sets: PrintLambdaSets,
 }
 
 /// How many times a root variable appeared in Subs.
@@ -370,9 +376,14 @@ fn content_to_string(
     home: ModuleId,
     interns: &Interns,
     named_result: NamedResult,
+    print_lambda_sets: PrintLambdaSets,
 ) -> String {
     let mut buf = String::new();
-    let env = Env { home, interns };
+    let env = Env {
+        home,
+        interns,
+        print_lambda_sets,
+    };
     let mut ctx = Context {
         able_variables: vec![],
         recursion_structs_to_expand: named_result.recursion_structs_to_expand,
@@ -397,10 +408,18 @@ pub fn name_and_print_var(
     subs: &mut Subs,
     home: ModuleId,
     interns: &Interns,
+    print_lambda_sets: PrintLambdaSets,
 ) -> String {
     let named_result = name_all_type_vars(var, subs);
     let content = subs.get_content_without_compacting(var);
-    content_to_string(content, subs, home, interns, named_result)
+    content_to_string(
+        content,
+        subs,
+        home,
+        interns,
+        named_result,
+        print_lambda_sets,
+    )
 }
 
 pub fn get_single_arg<'a>(subs: &'a Subs, args: &'a AliasVariables) -> &'a Content {
@@ -559,7 +578,53 @@ fn write_content<'a>(
                 }),
             }
         }
-        LambdaSet(_) => {
+        LambdaSet(subs::LambdaSet {
+            solved,
+            recursion_var,
+            unspecialized,
+        }) => {
+            buf.push_str("[[");
+
+            write_sorted_tags2(
+                env,
+                ctx,
+                subs,
+                buf,
+                solved.unsorted_lambdas(subs),
+                |symbol| symbol.as_str(&env.interns),
+            );
+
+            buf.push(']');
+
+            if let Some(rec_var) = recursion_var.into_variable() {
+                buf.push_str(" as ");
+                write_content(
+                    env,
+                    ctx,
+                    subs.get_content_without_compacting(rec_var),
+                    subs,
+                    buf,
+                    parens,
+                )
+            }
+
+            for Uls(var, member, region) in subs.get_subs_slice(*unspecialized) {
+                buf.push_str(" + ");
+                write_content(
+                    env,
+                    ctx,
+                    subs.get_content_without_compacting(*var),
+                    subs,
+                    buf,
+                    Parens::Unnecessary,
+                );
+                buf.push(':');
+                buf.push_str(member.as_str(&env.interns));
+                buf.push(':');
+                buf.push_str(&region.to_string());
+            }
+
+            buf.push(']');
             // lambda sets never exposed to the user
         }
         RangedNumber(typ, _range_vars) => write_content(
@@ -678,19 +743,19 @@ fn write_ext_content<'a>(
     }
 }
 
-fn write_sorted_tags2<'a>(
-    env: &Env,
+fn write_sorted_tags2<'a, 'b, L: 'b>(
+    env: &'b Env,
     ctx: &mut Context<'a>,
     subs: &'a Subs,
     buf: &mut String,
-    tags: &UnionTags,
-    ext_var: Variable,
-) -> ExtContent<'a> {
-    // Sort the fields so they always end up in the same order.
-    let (tags, new_ext_var) = tags.unsorted_tags_and_ext(subs, ext_var);
+    tags: UnsortedUnionLabels<'b, L>,
+    label_to_string: impl Fn(&'b L) -> &'b str,
+) where
+    L: Label + Ord,
+{
     let mut sorted_fields = tags.tags;
 
-    sorted_fields.sort_by(|(a, _), (b, _)| a.as_ident_str().cmp(&b.as_ident_str()));
+    sorted_fields.sort_by(|(a, _), (b, _)| a.cmp(&b));
 
     let mut any_written_yet = false;
 
@@ -701,7 +766,7 @@ fn write_sorted_tags2<'a>(
             any_written_yet = true;
         }
 
-        buf.push_str(label.as_ident_str().as_str());
+        buf.push_str(label_to_string(label));
 
         for var in vars {
             buf.push(' ');
@@ -715,8 +780,6 @@ fn write_sorted_tags2<'a>(
             );
         }
     }
-
-    ExtContent::from_var(subs, new_ext_var)
 }
 
 fn write_sorted_tags<'a>(
@@ -794,10 +857,11 @@ fn write_flat_type<'a>(
         ),
         EmptyRecord => buf.push_str(EMPTY_RECORD),
         EmptyTagUnion => buf.push_str(EMPTY_TAG_UNION),
-        Func(args, _closure, ret) => write_fn(
+        Func(args, closure, ret) => write_fn(
             env,
             ctx,
             subs.get_subs_slice(*args),
+            *closure,
             *ret,
             subs,
             buf,
@@ -869,11 +933,20 @@ fn write_flat_type<'a>(
         TagUnion(tags, ext_var) => {
             buf.push('[');
 
-            let ext_content = write_sorted_tags2(env, ctx, subs, buf, tags, *ext_var);
+            // Sort the fields so they always end up in the same order.
+            let (tags, new_ext_var) = tags.unsorted_tags_and_ext(subs, *ext_var);
+            write_sorted_tags2(env, ctx, subs, buf, tags, |tag| tag.0.as_str());
 
             buf.push(']');
 
-            write_ext_content(env, ctx, subs, buf, ext_content, parens)
+            write_ext_content(
+                env,
+                ctx,
+                subs,
+                buf,
+                ExtContent::from_var(subs, new_ext_var),
+                parens,
+            )
         }
 
         FunctionOrTagUnion(tag_name, _, ext_var) => {
@@ -891,11 +964,19 @@ fn write_flat_type<'a>(
         RecursiveTagUnion(rec_var, tags, ext_var) => {
             buf.push('[');
 
-            let ext_content = write_sorted_tags2(env, ctx, subs, buf, tags, *ext_var);
+            let (tags, new_ext_var) = tags.unsorted_tags_and_ext(subs, *ext_var);
+            write_sorted_tags2(env, ctx, subs, buf, tags, |tag| tag.0.as_str());
 
             buf.push(']');
 
-            write_ext_content(env, ctx, subs, buf, ext_content, parens);
+            write_ext_content(
+                env,
+                ctx,
+                subs,
+                buf,
+                ExtContent::from_var(subs, new_ext_var),
+                parens,
+            );
 
             buf.push_str(" as ");
             write_content(
@@ -1071,6 +1152,7 @@ fn write_fn<'a>(
     env: &Env,
     ctx: &mut Context<'a>,
     args: &[Variable],
+    closure: Variable,
     ret: Variable,
     subs: &'a Subs,
     buf: &mut String,
@@ -1100,7 +1182,24 @@ fn write_fn<'a>(
         );
     }
 
+    match env.print_lambda_sets {
+        PrintLambdaSets::No => {
             buf.push_str(" -> ");
+        }
+        PrintLambdaSets::Yes => {
+            buf.push_str(" -");
+            write_content(
+                env,
+                ctx,
+                subs.get_content_without_compacting(closure),
+                subs,
+                buf,
+                parens,
+            );
+            buf.push_str("->");
+        }
+    }
+
     write_content(
         env,
         ctx,

editor/src/editor/mvc/ed_update.rs

@@ -60,6 +60,7 @@ use roc_module::ident::Lowercase;
 use roc_module::symbol::Symbol;
 use roc_region::all::Region;
 use roc_types::pretty_print::name_and_print_var;
+use roc_types::pretty_print::PrintLambdaSets;
 use roc_types::solved_types::Solved;
 use roc_types::subs::{Subs, VarStore, Variable};
 use snafu::OptionExt;
@@ -462,8 +463,13 @@ impl<'a> EdModel<'a> {
 
         let subs = solved.inner_mut();
 
-        let pretty_var =
-            name_and_print_var(var, subs, self.module.env.home, &self.loaded_module.interns);
+        let pretty_var = name_and_print_var(
+            var,
+            subs,
+            self.module.env.home,
+            &self.loaded_module.interns,
+            PrintLambdaSets::No,
+        );
 
         PoolStr::new(&pretty_var, self.module.env.pool)
     }

repl_cli/src/lib.rs

@@ -23,7 +23,7 @@ use roc_repl_eval::{ReplApp, ReplAppMemory};
 use roc_reporting::report::DEFAULT_PALETTE;
 use roc_std::RocStr;
 use roc_target::TargetInfo;
-use roc_types::pretty_print::name_and_print_var;
+use roc_types::pretty_print::{name_and_print_var, PrintLambdaSets};
 
 const BLUE: &str = "\u{001b}[36m";
 const PINK: &str = "\u{001b}[35m";
@@ -227,7 +227,8 @@ fn gen_and_eval_llvm<'a>(
     let main_fn_var = *main_fn_var;
 
     // pretty-print the expr type string for later.
-    let expr_type_str = name_and_print_var(main_fn_var, &mut subs, home, &interns);
+    let expr_type_str =
+        name_and_print_var(main_fn_var, &mut subs, home, &interns, PrintLambdaSets::No);
     let content = subs.get_content_without_compacting(main_fn_var);
 
     let (_, main_fn_layout) = match procedures.keys().find(|(s, _)| *s == main_fn_symbol) {

repl_wasm/src/repl.rs

@@ -12,7 +12,7 @@ use roc_repl_eval::{
 };
 use roc_reporting::report::DEFAULT_PALETTE_HTML;
 use roc_target::TargetInfo;
-use roc_types::pretty_print::name_and_print_var;
+use roc_types::pretty_print::{name_and_print_var, PrintLambdaSets};
 
 use crate::{js_create_app, js_get_result_and_memory, js_run_app};
 
@@ -184,7 +184,7 @@ pub async fn entrypoint_from_js(src: String) -> Result<String, String> {
     let main_fn_var = *main_fn_var;
 
     // pretty-print the expr type string for later.
-    let expr_type_str = name_and_print_var(main_fn_var, &mut subs, module_id, &interns);
+    let expr_type_str = name_and_print_var(main_fn_var, &mut subs, module_id, &interns, PrintLambdaSets::No);
     let content = subs.get_content_without_compacting(main_fn_var);
 
     let (_, main_fn_layout) = match procedures.keys().find(|(s, _)| *s == main_fn_symbol) {