The catch statement doesn't print the text. Seen with scala 2.8.1, 2.9.2 and now 2.10.x.

welp.scala

object Welp {
  def foobar(a: Int, b: Int, c:Int) { throw new IllegalArgumentException }

  def main(args: Array[String]) {
    List(3) map { 
      try { 
        foobar(1, 2, _) 
      } catch {
      case e: Throwable => { // This set of braces is optional. Problem remains when removed.
       println("won't be printed")                                                   
       throw e
      }}
    }
  }
}

xrunit.sh

#!/bin/bash

scalac Welp.scala && scala -classpath . Welp

I hope this does justice to the suffering of all involved.

/** Top-level component for welp.com domain.
 *  Therefore, must never throw an exception.
 */
object Welp {
  /** Start serving welp pages. */
  def f(a: Int, b: Int, c: String) { throw new IllegalArgumentException }

  def fail(e: Throwable) = throw new RuntimeException(s"""${"*" * 30}
    |Dan, I hope you see this in the log file,
    |because the server just crashed.
    |
    |Dan, wake up!
    |${e.getMessage}
    |${"*" * 30}
    |""".stripMargin)

  def main(args: Array[String]): Unit = args map {
    try f(1, 2, _)
    catch {
      case e: Throwable => Console.err println "Failing..." ; fail(e)
    }
  }
}

with the joke answer (because it's multiple choice)

Prints:
Failing...
and wakes Dan at 3 a.m. when someone notices the server is down.

Feel free to comment on PR; though the puzzler guys are good at polishing.

The title is "Catch me if you can." Of course.

BTW, the puzzler guys are going to cut down some trees and print puzzlers on them. If you want your name associated with said puzzles, or if you wish to deny all association, you should tell them. The puzzler links to the ML discussion, as a rule.

@adriaanm Oh, yeah, my commenting out the throw actually made it not compile. I've put it back.

Now I just wonder what properly contains means in plain English.

That isn't plain English, but "math English". I think "properly" there is analogous to proper subset, even though we're not talking about sets: an expression e1 is properly contained into e2 if e1 is contained in e2 and e1 is different from e2. But I guess clarifying this in the spec could be a good idea.