&gt; Handling effects this way would presumably have the same problems?<p>First, I didn&#x27;t suggest actually using checked exceptions as they are now to model &quot;typesafe continuations&quot; in Java. I&#x27;m perfectly fine with continuations not being fully type-checked (I like types, but I&#x27;m far from a type zealot).<p>But more to the point, such an effect system (or actually even Java&#x27;s checked exceptions) won&#x27;t pose such a problem at all. On the contrary. Just like you can&#x27;t store a monadic value in a variable of a &quot;plain&quot; value, it makes sense to reject `int foo() throws IO` from a computation that doesn&#x27;t support IO. It is a problem in Java with checked exceptions because `int foo() throws InterruptedException` would work where `int f()` is expected, and having it rejected (and requiring a wrapper) is indeed a nuisance. That&#x27;s not the same issue if effects are involved.<p>&gt; I can use the former as a value whereas the latter I can only throw from methods. That&#x27;s the difference I&#x27;m worried about here.<p>I&#x27;m not sure I understand the distinction. You can always use something like Optional (Maybe) if you want a value. Alternatively, no one is stopping you from using the monadic Either even in an imperative context (although you may lose the stack trace). You can still use it this way if that&#x27;s how you like doing things. I don&#x27;t.<p>&gt; then which semantics do I get, and how do I get the other one?<p><pre><code>    throwc(new MyException());
    add(Writer.class, &quot;Here&quot;);
</code></pre>
would never call the writer (like your first example, I believe), while<p><pre><code>    tryc(() -&gt; {
           add(Writer.class, &quot;Here&quot;);
           ...
        },
    &#x2F;&#x2F; catch:
        (MyException e) -&gt; 
             add(Writer.class, e));
</code></pre>
would log the exception, as in your second example.<p>You don&#x27;t even need to think about it. It works just like plain imperative code. Continuations are the general (mathematical if you will) formulation of how imperative code already behaves.