remove debug prints

compiler/load/src/file.rs

@@ -2671,7 +2671,6 @@ fn fabricate_effects_module<'a>(
     //    }
 
     let constraint = constrain_module(&module_output, module_id, mode, &mut var_store);
-    dbg!(&module_output.aliases);
 
     let module = Module {
         module_id,
@@ -3037,8 +3036,6 @@ fn add_def_to_module<'a>(
                     // this is a top-level definition, it should not capture anything
                     debug_assert!(captured_symbols.is_empty());
 
-                    dbg!(symbol, &loc_body.value);
-
                     // If this is an exposed symbol, we need to
                     // register it as such. Otherwise, since it
                     // never gets called by Roc code, it will never

compiler/mono/src/ir.rs

@@ -419,7 +419,6 @@ impl<'a> Procs<'a> {
 
         match patterns_to_when(env, layout_cache, loc_args, ret_var, loc_body) {
             Ok((_, pattern_symbols, body)) => {
-                dbg!(symbol, &pattern_symbols, &body);
                 // an anonymous closure. These will always be specialized already
                 // by the surrounding context, so we can add pending specializations
                 // for them immediately.
@@ -588,7 +587,6 @@ impl<'a> Procs<'a> {
                 self.specialized
                     .insert((symbol, layout.clone()), InProgress);
 
-                dbg!(symbol, &pending);
                 match specialize(env, self, symbol, layout_cache, pending, partial_proc) {
                     Ok((proc, _ignore_layout)) => {
                         // the `layout` is a function pointer, while `_ignore_layout` can be a
@@ -615,7 +613,6 @@ fn add_pending<'a>(
     layout: Layout<'a>,
     pending: PendingSpecialization,
 ) {
-    // dbg!(symbol, &layout, &pending);
     let all_pending = pending_specializations
         .entry(symbol)
         .or_insert_with(|| HashMap::with_capacity_and_hasher(1, default_hasher()));
@@ -1339,7 +1336,6 @@ pub fn specialize_all<'a>(
     mut procs: Procs<'a>,
     layout_cache: &mut LayoutCache<'a>,
 ) -> Procs<'a> {
-    dbg!(&procs.externals_others_need);
     let it = procs.externals_others_need.specs.clone();
     let it = it
         .into_iter()
@@ -1408,7 +1404,6 @@ pub fn specialize_all<'a>(
                 procs
                     .specialized
                     .insert((name, outside_layout.clone()), InProgress);
-                dbg!(name);
                 match specialize(
                     env,
                     &mut procs,
@@ -1456,8 +1451,6 @@ fn specialize_external<'a>(
     host_exposed_variables: &[(Symbol, Variable)],
     partial_proc: PartialProc<'a>,
 ) -> Result<Proc<'a>, LayoutProblem> {
-    println!("------- SPECIALIZE EXTERNAL {:?}", proc_name);
-
     let PartialProc {
         annotation,
         pattern_symbols,
@@ -1466,8 +1459,6 @@ fn specialize_external<'a>(
         is_self_recursive,
     } = partial_proc;
 
-    dbg!(&body);
-
     // unify the called function with the specialized signature, then specialize the function body
     let snapshot = env.subs.snapshot();
     let cache_snapshot = layout_cache.snapshot();
@@ -1561,8 +1552,6 @@ fn specialize_external<'a>(
                 None => None,
             };
 
-            println!("Done for {:?}\n\n", proc_name);
-
             let proc = Proc {
                 name: proc_name,
                 args: proc_args,

examples/effect/Main.roc

@@ -4,6 +4,7 @@ app Main provides [ main ] imports [ Effect ]
 
 main : Effect.Effect {} as Fx
 main =
-    e = Effect.putChar 68
+    d = Effect.putChar 68
+    e = Effect.putChar 69
     
     e |> Effect.after \{} -> e