Never perform box inference

b-studios · b-studios · commit 427877f83044 · 2025-07-31T17:03:42.000+02:00
diff --git a/effekt/shared/src/main/scala/effekt/typer/BoxUnboxInference.scala b/effekt/shared/src/main/scala/effekt/typer/BoxUnboxInference.scala
@@ -52,12 +52,12 @@ object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
     case v: Var => v.definition match {
       // TODO maybe we should synthesize a call to get here already?
       case sym: (ValueSymbol | symbols.RefBinder) => v
-      case sym: BlockSymbol => Box(Maybe.None(v.span.emptyAfter), v, v.span.synthesized).inheritPosition(v)
+      case sym: BlockSymbol => v //Box(Maybe.None(v.span.emptyAfter), v, v.span.synthesized).inheritPosition(v)
     }
 
-    case n: New => Box(Maybe.None(n.span.emptyAfter), rewriteAsBlock(n), n.span.synthesized).inheritPosition(n)
+    case n: New => rewriteAsBlock(n) // Box(Maybe.None(n.span.emptyAfter), rewriteAsBlock(n), n.span.synthesized).inheritPosition(n)
 
-    case b: BlockLiteral => Box(Maybe.None(b.span.emptyAfter), rewriteAsBlock(b), b.span.synthesized).inheritPosition(b)
+    case b: BlockLiteral => rewriteAsBlock(b) // Box(Maybe.None(b.span.emptyAfter), rewriteAsBlock(b), b.span.synthesized).inheritPosition(b)
 
     case l: Literal => l
 
diff --git a/examples/benchmarks/are_we_fast_yet/bounce.effekt b/examples/benchmarks/are_we_fast_yet/bounce.effekt
@@ -16,7 +16,7 @@ def randomBall { rand: Random }: Ball at {global} = {
   val y = ref(toDouble(rand.next().mod(500)));
   val xVel = ref(toDouble(rand.next().mod(300) - 150));
   val yVel = ref(toDouble(rand.next().mod(300) - 150));
-  new Ball {
+  box new Ball {
     def bounce() = {
       val xLimit = 500.0;
       val yLimit = 500.0;
diff --git a/examples/benchmarks/other/generator.effekt b/examples/benchmarks/other/generator.effekt
@@ -30,7 +30,7 @@ def generator { prog: => Unit / Yield } {r: Region}: Generator at {prog, r} = {
       cont = box { resume(()) }
     }
   }
-  new Generator {
+  box new Generator {
     def value() = v
     def next() = cont()
   }
diff --git a/examples/benchmarks/other/nbe.effekt b/examples/benchmarks/other/nbe.effekt
@@ -62,7 +62,7 @@ def reify(v: Value): Term / fresh = v match {
 /// strong normalization of the term
 def normalize(t: Term): Term = {
   var i = 0
-  try reify(eval(empty[Name, Value](compareInt), t))
+  try reify(eval(empty[Name, Value](box compareInt), t))
   with fresh { i = i + 1; resume(i) }
 }
 
diff --git a/examples/benchmarks/other/variadic_combinators.effekt b/examples/benchmarks/other/variadic_combinators.effekt
@@ -41,7 +41,7 @@ def f3(fs: List[=> (Int => Int at {}) at {}]) =
     else first(fs)()(n - 1)
   }
 
-def mod3(x: Int): Int = first(vfix([f1, f2, f3]))()(x)
+def mod3(x: Int): Int = first(vfix([box f1, box f2, box f3]))()(x)
 
 def run(n: Int) = {
   mod3(n) + mod3(n + 1) + mod3(n + 2)
diff --git a/examples/llvm/issue1012.effekt b/examples/llvm/issue1012.effekt
@@ -7,7 +7,7 @@ def use { g: (Int) => Int } : Int = {
 }
 
 def main() : Unit = {
-  val t = [f]
+  val t = [box f]
   list::map(t) { y => use {y} }
   println("hi")
-}
+}
diff --git a/examples/llvm/nosuchelement.effekt b/examples/llvm/nosuchelement.effekt
@@ -9,7 +9,7 @@ def id[A](f: ((A) => Unit at {io, global}) => Unit at {io, global}): ((A) => Uni
 // [error] java.util.NoSuchElementException: key not found: h
 def main() = {
   val f = box { (n: Int) => println(n) }
-  def h = id(g);
+  def h = id(box g);
   val x = h(f);
   println(x)
 }
diff --git a/examples/llvm/prompt-duplication.effekt b/examples/llvm/prompt-duplication.effekt
@@ -9,8 +9,8 @@ def main() : Unit = {
     } with E { () =>
         def f() = { () }
         def g() = {
-          resume(f)
+          resume(box f)
         }
-        resume(g)
+        resume(box g)
     }
 }
diff --git a/examples/neg/blocks_in_value_pos.check b/examples/neg/blocks_in_value_pos.check
@@ -2,5 +2,5 @@
   Unit
 but got type
   () => Unit / { MyPrint } at ?C
-    resume(prog);
-           ^^^^
+    resume(box prog);
+           ^^^^^^^^
diff --git a/examples/neg/blocks_in_value_pos.effekt b/examples/neg/blocks_in_value_pos.effekt
@@ -4,6 +4,6 @@ effect MyPrint(n: Int): Unit
 
 def main { prog: => Unit / MyPrint } =
   try { prog(); prog() } with MyPrint { (n: Int) =>
-    resume(prog);
+    resume(box prog);
     println(n)
   }
diff --git a/examples/neg/issue365.check b/examples/neg/issue365.check
@@ -1,3 +1,3 @@
 [error] examples/neg/issue365.effekt:8:28: Not allowed {io}
-  val unboxed: Cap at {} = myCap;
-                           ^^^^^
+  val unboxed: Cap at {} = box myCap;
+                           ^^^^^^^^^
diff --git a/examples/neg/issue365.effekt b/examples/neg/issue365.effekt
@@ -5,6 +5,6 @@ extern io def cap(): Cap at {} = default { <> }
 
 def main() = {
   def myCap = cap()
-  val unboxed: Cap at {} = myCap;
+  val unboxed: Cap at {} = box myCap;
   ()
-}
+}
diff --git a/examples/neg/issue512.effekt b/examples/neg/issue512.effekt
@@ -6,9 +6,9 @@ def main() = {
   def myref =
     region r1 { // ERROR r1
       var x in r1 = "hoho";
-      new Ref[String] {
+      box new Ref[String] {
         def get() = x
       }
     }
   println(myref.get())
-}
+}
diff --git a/examples/pos/capture/borrows.effekt b/examples/pos/capture/borrows.effekt
@@ -6,9 +6,9 @@ interface Borrowed[T] {
 
 def main() = {
   var counter = 22;
-  val p : Borrowed[Int] at {counter} = new Borrowed[Int] {
+  val p : Borrowed[Int] at {counter} = box new Borrowed[Int] {
     def dereference() = counter
   };
   counter = counter + 1;
   println(p.dereference)
-}
+}
diff --git a/examples/pos/capture/defdef.effekt b/examples/pos/capture/defdef.effekt
@@ -9,15 +9,15 @@ def myModule { eff : Eff } = region this {
   def test1() = x();
   def test1b = x;
 
-  val f: () => Unit at {eff} = test1b;
+  val f: () => Unit at {eff} = box test1b;
 
   def test2() = {
     test1();
     var x in outer = 42; x
   };
-  val g = test2;
+  val g = box test2;
 
   ()
 }
 
-def main() = ()
+def main() = ()
diff --git a/examples/pos/capture/mbed.effekt b/examples/pos/capture/mbed.effekt
@@ -67,7 +67,7 @@ def loop[T] { f: => Unit / Loop[T] }: T = {
 }
 
 
-def DigitalOut(name: String) = new Output {
+def DigitalOut(name: String) = box new Output {
   def set(n: Bool) = useOut()
   def get() = { useOut(); true }
 }
@@ -99,7 +99,7 @@ def main() = {
     if (x <= 0) do break("STOP");
 
     // also ok!
-    precise.timeout(100.millis, flip)
+    precise.timeout(100.millis, box flip)
   }
 
   // not allowed!
diff --git a/examples/pos/capture/regions.effekt b/examples/pos/capture/regions.effekt
@@ -16,7 +16,7 @@ def makeCounter {r: Region} = {
     def get() = state
     def inc() = state = state + 1
   }
-  c1
+  box c1
 }
 
 def twoCounters() = {
@@ -43,7 +43,7 @@ def twoCounters() = {
       val _ = {
         def c1 = makeCounter {inner}
         def c2 = makeCounter {outer}
-        val l = Cons(c1, Cons(c2, Nil()));
+        val l = Cons(box c1, Cons(box c2, Nil()));
         ()
       };
       ()
@@ -73,7 +73,7 @@ def testLifted2() = try {
       def get() = do Get()
       def inc() = ()
     };
-    obj
+    box obj
   }
   // should print 42
   println(o.get())
@@ -95,7 +95,7 @@ def main() = region this {
     c1.inc()
     println(c1.get())
 
-    val boxed = c1;
+    val boxed = box c1;
     boxed
   };
 
@@ -107,4 +107,4 @@ def main() = region this {
   // testLifted2();
 
   ()
-}
+}
diff --git a/examples/pos/capture/resources.effekt b/examples/pos/capture/resources.effekt
@@ -19,7 +19,7 @@ def parameter[T] {a: Array[T]} = {
 }
 
 def main() = {
-  val f: () => Int at {foo} = user;
+  val f: () => Int at {foo} = box user;
   val arr = makeArray[Int](10);
   inspect(arr);
   ()
diff --git a/examples/pos/global_capabilities.effekt b/examples/pos/global_capabilities.effekt
@@ -29,7 +29,7 @@ def globalCapabilities { console: MyConsole } { time: Time }: Unit = {
   val repeatTime = repeater { sayTime };
 
   // some more variants illustrating closure and capability sets
-  val b = sayTime;
+  val b = box sayTime;
 
   val n = repeater { () => sayTime() };
   val n1 = repeater { sayTime };
@@ -50,7 +50,7 @@ def localCapabilities { console: MyConsole } { time: Time }: Unit =
   }
 
 def effectHandlers { console: MyConsole } { time: Time }: Unit = {
-  def report(t: Int) = console.myprintln(show(t) ++ "ms") 
+  def report(t: Int) = console.myprintln(show(t) ++ "ms")
   val before = time.now();
 
   try {
@@ -73,7 +73,7 @@ def run[T] { prog : {MyConsole} {Time} => T }: T = {
     } with console: MyConsole {
         def myprintln(msg) = { println(msg); resume(()) }
     } with time: Time {
-        def now() = { 
+        def now() = {
 			i = i + 1
 			resume(i)
 		}
diff --git a/examples/stdlib/map/cache.effekt b/examples/stdlib/map/cache.effekt
@@ -8,7 +8,7 @@ effect time(): Int
 def main() = {
   var currentTime = 0
   try {
-    var cache: Map[String, CacheEntry[String]] = map::empty(compareStringBytes)
+    var cache: Map[String, CacheEntry[String]] = map::empty(box compareStringBytes)
     val maxAge = 8
 
     def cachePut(key: String, value: String): Unit =
diff --git a/examples/stdlib/map/counter.effekt b/examples/stdlib/map/counter.effekt
@@ -3,7 +3,7 @@ import map
 import bytearray
 
 def counter(words: List[String]): Map[String, Int] = {
-  var m: Map[String, Int] = map::empty(compareStringBytes);
+  var m: Map[String, Int] = map::empty(box compareStringBytes);
 
   list::foreach(words) { word =>
     m = m.putWithKey(word, 1) { (_, n1, n2) => n1 + n2 }
diff --git a/examples/stdlib/map/map.effekt b/examples/stdlib/map/map.effekt
@@ -3,7 +3,7 @@ import map
 def main() = {
     val l = [(0, "Hello"), (1, "World"), (2, "Woo!")]
 
-    val m = map::fromList(l, compareInt)
+    val m = map::fromList(l, box compareInt)
     println(map::internal::prettyPairs(m.toList) { n => show(n) } { s => show(s) })
 
     val m2 = m.put(-1, "Hullo")
@@ -17,12 +17,12 @@ def main() = {
     val m4 = m.delete(1).put(42, "Whole new world!").put(100, "Big").put(1000, "Bigger").put(10000, "Biggest!")
     println(map::internal::prettyPairs(m4.toList) { n => show(n) } { s => show(s) })
 
-    val m5 = map::fromList(Cons((1, "Foo"), Cons((-1, "Huh?!"), m4.toList.reverse)), compareInt)
+    val m5 = map::fromList(Cons((1, "Foo"), Cons((-1, "Huh?!"), m4.toList.reverse)), box compareInt)
     println(map::internal::prettyPairs(m5.toList) { n => show(n) } { s => show(s) })
 
-    val m6: Map[Int, String] = m5.toList.fromList(compareInt)
+    val m6: Map[Int, String] = m5.toList.fromList(box compareInt)
     println(map::internal::prettyPairs(m6.toList) { n => show(n) } { s => show(s) })
 
-    val nuMap = map::fromList(l.reverse, compareInt)
+    val nuMap = map::fromList(l.reverse, box compareInt)
     println(map::internal::prettyPairs(nuMap.toList) { n => show(n) } { s => show(s) })
 }
diff --git a/examples/stdlib/map/minmax.effekt b/examples/stdlib/map/minmax.effekt
@@ -6,7 +6,7 @@ def show(opt: Option[(Int, String)]): String = opt match {
 }
 
 def main() = {
-  val m = map::fromList([(10, "Ten"), (20, "Twenty"), (5, "Five"), (30, "Thirty")], compareInt)
+  val m = map::fromList([(10, "Ten"), (20, "Twenty"), (5, "Five"), (30, "Thirty")], box compareInt)
 
   val min: Option[(Int, String)] = m.getMin
   val max: Option[(Int, String)] = m.getMax
diff --git a/examples/stdlib/map/setops.effekt b/examples/stdlib/map/setops.effekt
@@ -2,19 +2,19 @@ import map
 
 def main() = {
   // Create multiple maps
-  val map1 = map::fromList([(1, "apple"), (2, "banana"), (3, "cherry")], compareInt)
-  val map2 = map::fromList([(2, "berry"), (3, "date"), (4, "elderberry")], compareInt)
+  val map1 = map::fromList([(1, "apple"), (2, "banana"), (3, "cherry")], box compareInt)
+  val map2 = map::fromList([(2, "berry"), (3, "date"), (4, "elderberry")], box compareInt)
 
   // Test union with different combine strategies
   println("Union (keeping first value):")
   println(map::internal::prettyPairs(map1.union(map2).toList) { n => show(n) } { s => show(s) })
 
   println("\nUnion (combining values):")
-  val combinedMap = map1.union(map2, compareInt) { (k, v1, v2) => v1 ++ "/" ++ v2 }
+  val combinedMap = map1.union(map2, box compareInt) { (k, v1, v2) => v1 ++ "/" ++ v2 }
   println(map::internal::prettyPairs(combinedMap.toList) { n => show(n) } { s => show(s) })
 
   // Test intersection
   println("\nIntersection (combining keys):")
-  val intersectedMap = map1.intersection(map2, compareInt) { (k, v1, v2) => v1 ++ "-" ++ v2 }
+  val intersectedMap = map1.intersection(map2, box compareInt) { (k, v1, v2) => v1 ++ "-" ++ v2 }
   println(map::internal::prettyPairs(intersectedMap.toList) { n => show(n) } { s => show(s) })
 }
diff --git a/examples/stdlib/set/unique.effekt b/examples/stdlib/set/unique.effekt
@@ -3,7 +3,7 @@ import set
 import bytearray
 
 def unique(words: List[String]): Set[String] = {
-  var s: Set[String] = set::empty(compareStringBytes);
+  var s: Set[String] = set::empty(box compareStringBytes);
 
   list::foreach(words) { word =>
     s = s.insert(word)
@@ -58,8 +58,8 @@ def main() = {
   println(uniqueSpeech.toList)
   testSorted(uniqueSpeech)
 
-  println(set::fromList(speech, compareStringBytes).toList)
-  testSorted(set::fromList(speech, compareStringBytes))
+  println(set::fromList(speech, box compareStringBytes).toList)
+  testSorted(set::fromList(speech, box compareStringBytes))
 
   // ---
   println("")
diff --git a/examples/stdlib/stream/map.effekt b/examples/stdlib/stream/map.effekt
@@ -2,13 +2,13 @@ import stream
 import map
 
 def main() = {
-  val m = map::fromList([(1, 'H'), (2, 'e'), (3, 'l'), (4, 'l'), (5, 'o')], compareInt)
+  val m = map::fromList([(1, 'H'), (2, 'e'), (3, 'l'), (4, 'l'), (5, 'o')], box compareInt)
 
   for[(Int, Char)] { each(m) } { case (k, v) =>
     println(show(k) ++ ": " ++ show(v) ++ " (" ++ show(v.toInt) ++ ")")
   }
 
-  val newMap = collectMap[Int, Char](compareInt) { each(m) }
+  val newMap = collectMap[Int, Char](box compareInt) { each(m) }
   println(map::internal::prettyPairs(newMap.toList) { n => show(n) } { c => show(c) })
 
   val hello: String = collectString { eachValue(m) }
diff --git a/libraries/common/buffer.effekt b/libraries/common/buffer.effekt
@@ -62,11 +62,11 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
       tail.set(mod(tail.get + 1, initialCapacity))
     }
   }
-  buffer
+  box buffer
 }
 def refBuffer[T](): Buffer[T] at {global} = {
   val content = ref(None())
-  new Buffer[T] {
+  box new Buffer[T] {
     def capacity() = if (content.get.isEmpty) 1 else 0
     def full?() = content.get.isDefined
     def empty?() = isEmpty(content.get)
diff --git a/libraries/common/queue.effekt b/libraries/common/queue.effekt
@@ -103,7 +103,7 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
       tail.set(mod(tail.get + 1, capacity.get))
     }
   }
-  queue
+  box queue
 }
 
 namespace examples {

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ def generator { prog: => Unit / Yield } {r: Region}: Generator at {prog, r} = {`
`30`	`30`	`cont = box { resume(()) }`
`31`	`31`	`}`
`32`	`32`	`}`
`33`		`- new Generator {`
	`33`	`+ box new Generator {`
`34`	`34`	`def value() = v`
`35`	`35`	`def next() = cont()`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ def reify(v: Value): Term / fresh = v match {`
`62`	`62`	`/// strong normalization of the term`
`63`	`63`	`def normalize(t: Term): Term = {`
`64`	`64`	`var i = 0`
`65`		`- try reify(eval(empty[Name, Value](compareInt), t))`
	`65`	`+ try reify(eval(empty[Name, Value](box compareInt), t))`
`66`	`66`	`with fresh { i = i + 1; resume(i) }`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ def f3(fs: List[=> (Int => Int at {}) at {}]) =`
`41`	`41`	`else first(fs)()(n - 1)`
`42`	`42`	`}`
`43`	`43`
`44`		`-def mod3(x: Int): Int = first(vfix([f1, f2, f3]))()(x)`
	`44`	`+def mod3(x: Int): Int = first(vfix([box f1, box f2, box f3]))()(x)`
`45`	`45`
`46`	`46`	`def run(n: Int) = {`
`47`	`47`	`mod3(n) + mod3(n + 1) + mod3(n + 2)`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ def use { g: (Int) => Int } : Int = {`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`def main() : Unit = {`
`10`		`- val t = [f]`
	`10`	`+ val t = [box f]`
`11`	`11`	`list::map(t) { y => use {y} }`
`12`	`12`	`println("hi")`
`13`		`-}`
	`13`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ def id[A](f: ((A) => Unit at {io, global}) => Unit at {io, global}): ((A) => Uni`
`9`	`9`	`// [error] java.util.NoSuchElementException: key not found: h`
`10`	`10`	`def main() = {`
`11`	`11`	`val f = box { (n: Int) => println(n) }`
`12`		`- def h = id(g);`
	`12`	`+ def h = id(box g);`
`13`	`13`	`val x = h(f);`
`14`	`14`	`println(x)`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ def main() : Unit = {`
`9`	`9`	`} with E { () =>`
`10`	`10`	`def f() = { () }`
`11`	`11`	`def g() = {`
`12`		`- resume(f)`
	`12`	`+ resume(box f)`
`13`	`13`	`}`
`14`		`- resume(g)`
	`14`	`+ resume(box g)`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ effect MyPrint(n: Int): Unit`
`4`	`4`
`5`	`5`	`def main { prog: => Unit / MyPrint } =`
`6`	`6`	`try { prog(); prog() } with MyPrint { (n: Int) =>`
`7`		`- resume(prog);`
	`7`	`+ resume(box prog);`
`8`	`8`	`println(n)`
`9`	`9`	`}`