Redo `with` syntax.

Similar to redoing `match`, the `when` cases of a `with` expression
are now within braces, and the `else` clause is optional and cannot
have a binding.

TODO.md

···
 * Something wrong with `or` patterns when running JIT
 * Allow `with {}` (with a block)
 * Make blocks and expressions more interchangeable
-* Rethink syntax of cases (`with`)
-    * Add braces like most languages use
-    * `else yield` is default fallback for `when`
-    * Remove binding from `else _ then {}` case, as it will be optional and could just be a regular last case
 * Do a proper standard library design, maybe include a prelude
     * Type-agnostic global functions (similar to core, but safe)
     * Consistent interfaces to individual core standard modules

samples/first_class_resume.tri

···
 func doubleInto x into = into (2 * x)
 
 proc main!() {
-    exit with divBy 8 0
+    exit with divBy 8 0 {
         when 'INF cancel doubleInto 2 (resume)
         else yield
+    }
 }

samples/handler.tri

···
 func divBy x y = x / y
 
 proc main!() {
-    let x = with divBy 3 0
+    let x = with divBy 3 0 {
         when 'NAN cancel 0
         when 'INF resume 1
         else yield
+    }
 
-    let y = with divBy 4 "y"
+    let y = with divBy 4 "y" {
         when 'NAN cancel 9
         when 'INF resume 2
         else yield
+    }
 
-    let z = with divBy 4 2
+    let z = with divBy 4 2 {
         when 'NAN cancel 9
         when 'INF resume 4
         else yield
+    }
 
     exit x + y + z
 }

spec/src/syntax-and-semantics/effects/index.tex

···
         \bnfor
     } \\
     \bnfmore{
-        \bnfts{\kw{else}}
-        \bnfsp
-        \bnfpn{Binding}
-        \bnfsp
-        \bnfpn{Handler}
+        \bnfpn{EffectHandler}
         \bnfor
-    } \\
-    \bnfmore{
         \bnfts{\kw{else}}
         \bnfsp
-        \bnfpn{Expression}
+        \bnfpn{Handler}
     } \\
     \bnfprod{EffectHandler}{
         \bnfts{\kw{when}}
···
     \bnfmore{
         \bnfts{\kw{then}}
         \bnfsp
-        \bnfpn{Expression}
-        \bnfor
         \bnfpn{Block}
         \bnfor
-    } \\
-    \bnfmore{
         \bnfts{\kw{yield}}
         \bnfsp
         \bnfpn{Expression}
···
 \end{bnf*}
 
 Effect handlers are defined with \kw{when} and are either written in functional
-or imperative style. At the end of a chain of handlers, the \kw{else} clause is
-included to describe what to do in the case of no handler matching; the default
-choice should be \kw{else yield}, but in some situations there may be reason to
-do otherwise.
+or imperative style. At the end of a chain of handlers, an \kw{else} clause may be
+included to describe what to do in the case of no handler matching; if omitted,
+the default is as if it were written \kw{else yield}.
 
 Handlers install a contextual handler around a piece of code. When an effect is
 yielded, the ``nearest'' handler with a matching pattern and guard will be used
···
 to a handler in the parent scope (a re-yielded effect never gets handled by another
 handler on the same chain).
 
-A \kw{cancel} handler will not respond to the yielder, instead completing the entire expression
-or statement on which the handler was attached, as if the \kw{with} keyword evaluated
-to the value that \kw{cancel} was supplied.
+A \kw{cancel} handler will not respond to the yielder, instead completing the entire
+expression or statement on which the handler was attached, as if the \kw{with} keyword
+evaluated to the value that \kw{cancel} was supplied.
 
 A \kw{resume} handler will respond with the evaluation of the expression following
 the keyword. The \kw{yield} that performed the effect will evaluate to that value.

spec/src/syntax-and-semantics/poetry/handled.tex

···
         \bnfsp
         \bnfpn{Expression}
         \bnfsp
+        \bnfts{\{}
+        \bnfsp
         \bnfpn{EffectHandlers}
+        \bnfsp
+        \bnfts{\}}
     }
 \end{bnf*}
 
···
 \begin{prooftree}
     \AxiomC{$\Gamma\vdash E : \tau$}
     \LeftLabel{With}
-    \UnaryInfC{$\Gamma\vdash \kw{when}\ E : \tau$}
+    \UnaryInfC{$\Gamma\vdash \kw{with}\ E : \tau$}
 \end{prooftree}

testsuite/captured-resume/main.tri

···
 
 proc main!() {
   let mut res = unit
-  with yielding!()
+  with yielding!() {
     when 'capture then{
       res = (resume)
       cancel unit
     }
     when 'get_value resume 5
     else yield
+  }
 
   assert res 5 == 10
   assert res 20 == 25

testsuite/captured-return-shedding/main.tri

···
 
 proc inner!() {
   let ret = (return)
-  with ret 3
+  with ret 3 {
     when 'eff then {
       println!("hello")
       cancel false
     }
     else yield
+  }
 }
 
 proc outer!() {
···
 }
 
 proc main!() {
-  assert with outer!() when 'eff cancel true else cancel false
+  assert with outer!() { when 'eff cancel true else cancel false }
 }

testsuite/effects-break-after-resume/main.tri

···
 proc main!() {
   let mut x = 0
   while x < 5 {
-    with thing!(x)
+    with thing!(x) {
       when 'a(a) if a > 2 then { break unit }
       when 'a(a) then {
         let 'b(b) = resume a
         debug::dbg!('handler(b))
         cancel unit
       }
-      else yield
+    }
     x += 1
   }
   assert x == 3

testsuite/effects-cancel-mid-resume/main.tri

···
 }
 
 proc main!() {
-  let x = with inner!()
+  let x = with inner!() {
     when 'in then {
       if resume 'a
         then cancel 1
···
     }
     when 'out cancel false
     else yield
+  }
   assert "final result should be 2 but it was ${x}" as x == 2
 }

testsuite/effects-handle-and-end/main.tri

···
 }
 
 proc main!() {
-  with body!() when 'eff then {} else yield
+  with body!() { when 'eff then {} }
 }

testsuite/effects-just-cancel/main.tri

···
 }
 
 proc main!() {
-  let x = with inner!()
+  let x = with inner!() {
     when 'eff cancel 2
     else yield
+  }
   assert x == 2
 }

testsuite/effects-just-resume/main.tri

···
 }
 
 proc main!() {
-  with inner!()
+  with inner!() {
     when 'eff resume 1
     else yield
+  }
   assert "Unreachable" as false
 }

testsuite/effects-nested-cancel/main.tri

···
 }
 
 proc do_things!() {
-  with do_inner!() else yield
+  with do_inner!() { else yield }
   assert "don't go here" as false
   return false
 }
 
 proc main!() {
-  assert 'hello == with do_things!()
+  assert 'hello == with do_things!() {
     when 'get_hello cancel 'hello
     else yield
+  }
   println!("Made it to end")
 }

testsuite/effects-nested/main.tri

···
 
 proc do_things!() {
   return d!(8,
-    with d!(6, do_inner!())
-      else eff then {
+    with d!(6, do_inner!()) {
+      when eff then {
         cancel d!(7,
           resume d!(4,
             yield d!(2, eff)
           )
         )
       }
+    }
   )
 }
 
 proc main!() {
-  assert d!(11, with d!(9, do_things!())
+  assert d!(11, with d!(9, do_things!()) {
     when 'get_hello cancel d!(10, resume d!(3, 'hello))
-    else yield)
+    else yield
+  })
   dbg!("Made it to end")
 }

testsuite/effects-none-yielded/main.tri

···
 }
 
 proc main!() {
-  let y = with body!() else yield
+  let y = with body!() { else yield }
   assert y == 5
 }

testsuite/effects-resume-multiple/main.tri

···
 }
 
 proc main!() {
-  let result = with inner!()
+  let result = with inner!() {
     when a:b then {
       let first = resume a
       let second = resume b
       cancel first:second
     }
-    else yield
+  }
   assert "result is ${result}" as result == 1:2
 }

testsuite/effects-skip-handler/main.tri

···
 }
 
 proc outer!() {
-  return with inner!()
+  return with inner!() {
     when 'done then { return 3 }
     else yield
+  }
 }
 
 proc main!() {

testsuite/effects-through-more-returns/main.tri

···
 }
 
 proc main!() {
-  let x = with process!()
+  let x = with process!() {
     when 'both then {
       let a = resume true
       let b = resume false
       cancel a:b
     }
     else yield
+  }
   assert x == (('a:'c):('a:'d)):(('b:'c):('b:'d))
 }

testsuite/effects-through-return/main.tri

···
 }
 
 proc main!() {
-  let result = with inner!()
+  let result = with inner!() {
     when a:b then {
       let first = resume a
       let second = resume b
       cancel first:second
     }
     else yield
+  }
   assert "result is ${result}" as result == 1:2
 }

testsuite/effects-yield-fallback/main.tri

···
 }
 
 proc main!() {
-  with body!() else yield
+  with body!() { else yield }
   exit 1
 }

testsuite/effects-yield-in-loop/main.tri

···
 
 proc main!() {
   let mut x = 0
-  let result = with the_loop!()
+  let result = with the_loop!() {
     when 'a(a) then {
       let 'b(b) = resume 'b(a)
       debug::dbg!('handler(b))
       cancel 'b(b + 1)
     }
-    else yield
+  }
   assert result == 'b(3)
 }

testsuite/effects-yield-into-call/main.tri

···
 }
 
 proc main!() {
-  with inner!()
+  with inner!() {
     when 'a then {
       resume 1
       become 2
     }
-    else yield
+  }
 }

testsuite/effects-yield-nested/main.tri

···
 }
 
 proc do_things!() {
-  return with do_inner!() else yield
+  return with do_inner!() { else yield }
 }
 
 proc main!() {
-  assert with do_things!()
+  assert with do_things!() {
     when 'get_hello resume 'hello
     else yield
+  }
   println!("Made it to end")
 }

testsuite/koka-example/main.tri

···
 }
 
 proc choice!(action) {
-  return with [action!()]
+  return with [action!()] {
     when 'choice then {
       cancel [..resume false, ..resume true]
     }
-    else yield
+  }
 }
 
 proc surprising!() {
···
 
 proc pstate!(init, action) {
   let mut state = init
-  let result = with action!()
+  let result = with action!() {
     when 'get resume state
     when 'set(val) then {
       state = val
       become unit
     }
-    else yield
+  }
   return result:state
 }
 

testsuite/member-access/main.tri

···
 proc main!() {
   assert [1, 2, 3].2 == 3
   assert [1, 2, 3].0 == 1
-  assert with [1, 2, 3].4 when 'mia cancel true else cancel false
+  assert with [1, 2, 3].4 { when 'mia cancel true else cancel false }
 
   assert "hello".4 == 'o'
-  assert with "hello".5 when 'mia cancel true else cancel false
+  assert with "hello".5 { when 'mia cancel true else cancel false }
 
   assert {|'a' => 0, 'b' => 1, 'c' => 2|}.'a' == 0
   assert {|0 => 'a', 1 => 'b', 2 => 'c'|}.0 == 'a'
-  assert with {|0 => 'a', 1 => 'b', 2 => 'c'|}.3 when 'mia cancel true else cancel false
+  assert with {|0 => 'a', 1 => 'b', 2 => 'c'|}.3 { when 'mia cancel true else cancel false }
 }

testsuite/non-captured-return-shedding/main.tri

···
 import "trilogy:io" use println
 
 proc inner!() {
-  with return 3
+  with return 3 {
     when 'eff then {
       println!("hello")
       cancel false
     }
     else yield
+  }
 }
 
 proc outer!() {
···
 }
 
 proc main!() {
-  assert with outer!() when 'eff cancel true else cancel false
+  assert with outer!() { when 'eff cancel true else cancel false }
 }

testsuite/recursion-depth-yields/main.tri

···
 proc recursive!(i) {
   if i % 100_000 == 0 { dbg!(i) }
   if i == 1_000_000 { return unit }
-  with yield 'recurse
+  with yield 'recurse {
     when 'recurse resume recursive!(i + 1)
     else yield
+  }
 }
 
 proc main!() {

testsuite/unison-example/main.tri

···
 
 proc in_memory_with_map!(action) {
   let mut map = {||}
-  let result = with action!()
+  let result = with action!() {
     when 'get(k) resume match map {
       case {| ^k => v, .._ |} then 'some(v)
       else 'none
···
       map.k = v
       become unit
     }
-    else yield
+  }
   return result:map
 }
 

trilogy-ir/src/ir/handler.rs

···
                 converter.scope.set_allow_resume_cancel(false);
                 let else_span = handler.else_token().span;
                 let effect = Identifier::temporary(converter, else_span);
-                let pattern = handler
-                    .identifier
-                    .map(|id| Expression::reference(id.span(), Identifier::declare(converter, id)))
-                    .unwrap_or_else(|| Expression::wildcard(else_span));
-                let pattern = Expression::reference(else_span, effect.clone())
-                    .and(else_span.union(pattern.span), pattern);
+                let pattern = Expression::reference(else_span, effect.clone());
                 let guard = Expression::boolean(else_span, true);
                 converter.scope.set_allow_resume_cancel(true);
                 let body = Self::convert_strategy(converter, handler.strategy, effect);

trilogy-llvm/src/expression/mod.rs

···
             self.begin_next_function(next_case_function);
         }
 
-        // A handler is always complete by the syntax requiring an `else` case at the end, so the last
-        // branch is never reachable.
-        let unreachable = self.builder.build_unreachable().unwrap();
-        self.end_continuation_point_as_clean(unreachable);
+        self.push_handler_scope(resume);
+        let effect = self.use_temporary_clone(effect).unwrap();
+        let returned = self.call_yield(effect, "");
+        let resumed = self.call_resume(returned, "");
+        let cancel = self.allocate_value("");
+        self.trilogy_value_clone_into(cancel, self.get_cancel());
+        self.call_known_continuation(cancel, resumed);
+        self.pop_handler_scope();
     }
 
     fn compile_assertion(&self, assertion: &ir::Assert, name: &str) -> Option<PointerValue<'ctx>> {

trilogy-parser/src/syntax/else_handler.rs

···
-use super::{Identifier, *};
+use super::*;
 use crate::{Parser, Spanned};
 use source_span::Span;
-use trilogy_scanner::{
-    Token,
-    TokenType::{self, *},
-};
+use trilogy_scanner::{Token, TokenType};
 
 /// A fallback `else` handler for a handled `when` statement or expression.
 #[derive(Clone, Debug, PrettyPrintSExpr)]
 pub struct ElseHandler {
     pub r#else: Token,
-    pub identifier: Option<Identifier>,
     pub strategy: HandlerStrategy,
     span: Span,
 }
 
 impl ElseHandler {
     pub(crate) fn parse(parser: &mut Parser) -> SyntaxResult<Self> {
-        let r#else = parser.expect(KwElse).unwrap();
-
-        let identifier = if parser.check(TokenType::Identifier).is_ok() {
-            Some(Identifier::parse(parser).unwrap())
-        } else {
-            None
-        };
-
+        let r#else = parser.expect(TokenType::KwElse).unwrap();
         let strategy = HandlerStrategy::parse(parser)?;
 
         Ok(Self {
             span: r#else.span.union(strategy.span()),
             r#else,
-            identifier,
             strategy,
         })
     }
···
 mod test {
     use super::*;
 
-    test_parse!(elsehandler_yield: "else yield" => ElseHandler::parse => "(ElseHandler _ () _)");
-    test_parse!(elsehandler_resume_without_id: "else resume 3" => ElseHandler::parse => "(ElseHandler _ () _)");
-    test_parse!(elsehandler_resume_with_id: "else x resume x" => ElseHandler::parse => "(ElseHandler _ (Identifier) _)");
-    test_parse!(elsehandler_cancel_without_id: "else cancel 3" => ElseHandler::parse => "(ElseHandler _ () _)");
-    test_parse!(elsehandler_cancel_with_id: "else x cancel x" => ElseHandler::parse => "(ElseHandler _ (Identifier) _)");
+    test_parse!(elsehandler_yield: "else yield" => ElseHandler::parse => "(ElseHandler _ _)");
+    test_parse!(elsehandler_resume: "else resume 3" => ElseHandler::parse => "(ElseHandler _ _)");
+    test_parse!(elsehandler_cancel: "else cancel 3" => ElseHandler::parse => "(ElseHandler _ _)");
 }

trilogy-parser/src/syntax/handled_expression.rs

···
 pub struct HandledExpression {
     pub with: Token,
     pub expression: Expression,
+    pub obrace: Token,
     pub handlers: Vec<Handler>,
+    pub cbrace: Token,
     span: Span,
 }
 
···
 
         let expression = Expression::parse(parser)?;
 
+        let obrace = parser
+            .expect(OBrace)
+            .map_err(|token| parser.expected(token, "expected { to begin `with` handlers"))?;
+
         let mut handlers = vec![];
-        loop {
+        let cbrace = loop {
+            if let Ok(cbrace) = parser.expect(CBrace) {
+                break cbrace;
+            }
             if let Err(token) = parser.check([KwWhen, KwElse]) {
                 let error = SyntaxError::new(
                     token.span,
-                    "expected `when`, or `else` to with an effect handler",
+                    "expected `when`, or `else` to start an effect handler",
                 );
                 parser.error(error.clone());
                 return Err(error);
···
             let end = matches!(handler, Handler::Else(..));
             handlers.push(handler);
             if end {
-                return Ok(Self {
-                    span: with.span.union(handlers.last().unwrap().span()),
-                    with,
-                    expression,
-                    handlers,
-                });
+                break parser.expect(CBrace).map_err(|token| {
+                    parser.expected(token, "expected } to end `with` handlers")
+                })?;
             }
-        }
+        };
+        Ok(Self {
+            span: with.span.union(handlers.last().unwrap().span()),
+            with,
+            expression,
+            obrace,
+            handlers,
+            cbrace,
+        })
     }
 }
 
···
 mod test {
     use super::*;
 
-    test_parse!(handled_expr_else_yield: "with 3 else yield" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::Else _)])");
-    test_parse!(handled_expr_else_resume: "with 3 else resume 3" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::Else _)])");
-    test_parse!(handled_expr_else_cancel: "with 3 else cancel 3" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::Else _)])");
-    test_parse!(handled_expr_yield: "with 3 when 'x yield else yield" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::When _) (Handler::Else _)])");
-    test_parse_error!(handled_expr_resume_block: "with 3 when 'x resume {} else yield" => HandledExpression::parse);
-    test_parse_error!(handled_expr_cancel_block: "with 3 when 'x cancel {} else yield" => HandledExpression::parse);
-    test_parse!(handled_expr_resume_expr: "with 3 when 'x resume 3 else yield" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::When _) (Handler::Else _)])");
-    test_parse!(handled_expr_cancel_expr: "with 3 when 'x cancel 3 else yield" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::When _) (Handler::Else _)])");
-    test_parse!(handled_expr_multiple_yield: "with 3 when 'x yield when 'y yield else yield" => HandledExpression::parse => "(HandledExpression _ _ [(Handler::When _) (Handler::When _) (Handler::Else _)])");
+    test_parse!(handled_expr_else_yield: "with 3 { else yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::Else _)] _)");
+    test_parse!(handled_expr_else_resume: "with 3 { else resume 3 }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::Else _)] _)");
+    test_parse!(handled_expr_else_cancel: "with 3 { else cancel 3 }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::Else _)] _)");
+    test_parse!(handled_expr_yield: "with 3 { when 'x yield else yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::When _) (Handler::Else _)] _)");
+    test_parse_error!(handled_expr_resume_block: "with 3 { when 'x resume {} else yield }" => HandledExpression::parse);
+    test_parse_error!(handled_expr_cancel_block: "with 3 { when 'x cancel {} else yield }" => HandledExpression::parse);
+    test_parse!(handled_expr_resume_expr: "with 3 { when 'x resume 3 else yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::When _) (Handler::Else _)] _)");
+    test_parse!(handled_expr_cancel_expr: "with 3 { when 'x cancel 3 else yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::When _) (Handler::Else _)] _)");
+    test_parse!(handled_expr_multiple_yield: "with 3 { when 'x yield when 'y yield else yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::When _) (Handler::When _) (Handler::Else _)] _)");
     test_parse_error!(handled_expr_block: "with {} else yield" => HandledExpression::parse);
+    test_parse!(handled_expr_no_else: "with 3 { when 'x yield }" => HandledExpression::parse => "(HandledExpression _ _ _ [(Handler::When _)] _)");
 }

trilogy-parser/src/syntax/handler.rs

···
     use super::*;
 
     test_parse!(handler_when: "when 'NAN resume 5" => Handler::parse => "(Handler::When (WhenHandler _ _ _ _))");
-    test_parse!(handler_else: "else n resume 5" => Handler::parse => "(Handler::Else (ElseHandler _ _ _))");
+    test_parse!(handler_else: "else resume 5" => Handler::parse => "(Handler::Else (ElseHandler _ _))");
 }

trilogy/src/stdlib/array.tri

···
 
 test "array reduce" {
   assert reduce (+) [1, 2, 3, 4] == 10
-  assert with (reduce (+) []; false)
-    when 'mia cancel true
-    else yield
+  assert with (reduce (+) []; false) { when 'mia cancel true }
   assert reduce (:) [1, 2, 3] == (1:2):3
 }
 
···
 
 test "array rreduce" {
   assert rreduce (+) [1, 2, 3, 4] == 10
-  assert with (rreduce (+) []; false)
-    when 'mia cancel true
-    else yield
+  assert with (rreduce (+) []; false) { when 'mia cancel true }
   assert rreduce (:) [1, 2, 3] == (3:2):1
 }
 
···
 
 test "array first" {
   assert first [1, 2, 3] == 1
-  assert with (first []; false)
-    when 'mia cancel true
-    else yield
+  assert with (first []; false) { when 'mia cancel true }
 }
 
 func last [] = yield 'mia
···
 
 test "array last" {
   assert last [1, 2, 3] == 3
-  assert with (last []; false)
-    when 'mia cancel true
-    else yield
+  assert with (last []; false) { when 'mia cancel true }
 }
 
 func tail [] = yield 'mia
···
 
 test "array tail" {
   assert tail [1, 2, 3] == [2, 3]
-  assert with (tail []; false)
-    when 'mia cancel true
-    else yield
+  assert with (tail []; false) { when 'mia cancel true }
 }
 
 func head [] = yield 'mia
···
 
 test "array head" {
   assert head [1, 2, 3] == [1, 2]
-  assert with (head []; false)
-    when 'mia cancel true
-    else yield
+  assert with (head []; false) { when 'mia cancel true }
 }
 
 func slice i fin (arr and typeof 'array) = core::slice i fin arr
···
   assert slice 1 2 [1, 2, 3] == [2]
   assert slice 1 1 [1, 2, 3] == []
   assert slice 1 3 [1, 2, 3] == [2, 3]
-  assert with (slice (-1) 2 [1, 2, 3]; false)
-    when 'arg cancel true
-    else yield
-  assert with (slice 2 1 [1, 2, 3]; false)
-    when 'arg cancel true
-    else yield
-  assert with (slice 0 5 [1, 2, 3]; false)
-    when 'mia cancel true
-    else yield
-  assert with (slice 5 5 [1, 2, 3]; false)
-    when 'mia cancel true
-    else yield
+  assert with (slice (-1) 2 [1, 2, 3]; false) { when 'arg cancel true }
+  assert with (slice 2 1 [1, 2, 3]; false) { when 'arg cancel true }
+  assert with (slice 0 5 [1, 2, 3]; false) { when 'mia cancel true }
+  assert with (slice 5 5 [1, 2, 3]; false) { when 'mia cancel true }
 }
 
 func take n (arr and typeof 'array) =
···
   assert take 2 [1, 2, 3] == [1, 2]
   assert take 3 [1, 2, 3] == [1, 2, 3]
   assert take 12 [1, 2, 3] == [1, 2, 3]
-  assert with (take (-1) [1, 2, 3]; false)
-    when 'arg cancel true
-    else yield
+  assert with (take (-1) [1, 2, 3]; false) { when 'arg cancel true }
 }
 
 func skip n (arr and typeof 'array) =
···
   assert skip 2 [1, 2, 3] == [3]
   assert skip 3 [1, 2, 3] == []
   assert skip 12 [1, 2, 3] == []
-  assert with (skip (-1) [1, 2, 3]; false)
-    when 'arg cancel true
-    else yield
+  assert with (skip (-1) [1, 2, 3]; false) { when 'arg cancel true }
 }
 
 func drop n (arr and typeof 'array) =
···
   assert drop 2 [1, 2, 3] == [1]
   assert drop 3 [1, 2, 3] == []
   assert drop 12 [1, 2, 3] == []
-  assert with (drop (-1) [1, 2, 3]; false)
-    when 'arg cancel true
-    else yield
+  assert with (drop (-1) [1, 2, 3]; false) { when 'arg cancel true }
 }
 
 func collect iterator =
   let arr = [],
-  with (iterator!(); arr)
+  with (iterator!(); arr) {
     when 'next(val) then {
       push!(arr, val)
       become unit
     }
-    else yield
+  }
 
 test "array collect" {
   let iterator = do() {
···
   assert chunks 3 [1, 2, 3, 4, 5, 6, 7, 8, 9] == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
   assert chunks 3 [1, 2, 3, 4, 5, 6, 7] == [[1, 2, 3], [4, 5, 6], [7]]
   assert chunks 1 [1, 2, 3] == [[1], [2], [3]]
-  with chunks 0 when 'arg cancel unit else yield
+  with chunks 0 { when 'arg cancel unit }
 }
 
 func merge _ a [] = a

trilogy/src/stdlib/core.tri

···
 
   for test_name:test_procedure in tests {
     c::print!("test ${test_name} ... ")
-    with test_procedure!()
+    with test_procedure!() {
       when 'assertion_failed(msg) then {
         c::print!(red "assertion failed")
         c::print!(": ${msg}\n")
         failures += 1
         continue unit
       }
-      else eff then {
+      when eff then {
         c::print!(red "failure")
         c::print!(": unhandled effect yielded from test: ${eff}\n")
         failures += 1
         continue unit
       }
+    }
     c::print!(green "ok")
     c::print!("\n")
     successes += 1

trilogy/src/stdlib/grid.tri

···
 }
 
 proc shortest_path_length!(grid, from, to) {
-  return with algorithm::shortest_path_length!(from, to)
+  return with algorithm::shortest_path_length!(from, to) {
     when 'neighbours(from_pos) resume
       adjacent from_pos
       |> it::from
       |> it::filter (fn p. contains_key p grid)
       |> it::map (fn p. p:grid.p)
       |> array::collect
-    else yield
+  }
 }

trilogy/src/stdlib/heap.tri

···
 
   func collect iterator =
     let heap = [],
-    with (iterator!(); heap)
+    with (iterator!(); heap) {
       when 'next(val) then {
         push!(heap, val)
         become unit
       }
-      else yield
+    }
 }
 
 test "heap push" {

trilogy/src/stdlib/io.tri

···
 export readlines
 proc readlines!() {
   while true {
-    let line = with readline!()
+    let line = with readline!() {
       when 'eof cancel break unit
-      else yield
+    }
     yield 'next(line)
   }
 }

trilogy/src/stdlib/iterator.tri

···
 }
 
 test "iterator of" {
-  assert 3 == with run <| of 3 when 'next(val) cancel val else yield
-  assert unit == with run <| of 3 when 'next(3) resume 1 else yield
+  assert 3 == with run <| of 3 { when 'next(val) cancel val }
+  assert unit == with run <| of 3 { when 'next(3) resume 1 }
   assert collect <| of 3 == [3]
 }
 
···
 
 func take n it = do() {
   let mut i = 0
-  with it!()
+  with it!() {
     when 'next(val) if i < n then {
       i += 1
       become yield 'next(val)
     }
     when 'next(_) cancel unit
-    else yield
+  }
 }
 
 test "iterator take" {
···
 func chunks 0 _ = yield 'arg
 func chunks n it = do() {
   let mut chunk = []
-  with it!()
+  with it!() {
     when 'next(item) then {
       chunk = [..chunk, item]
       if array::length chunk == n {
···
       }
       become unit
     }
-    else yield
+  }
   if chunk != [] { yield 'next(chunk) }
 }
 
···
   assert collect <| chunks 3 <| range 1 9 == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
   assert collect <| chunks 3 <| range 1 7 == [[1, 2, 3], [4, 5, 6], [7]]
   assert collect <| chunks 1 <| range 1 3 == [[1], [2], [3]]
-  with chunks 0 when 'arg cancel unit else yield
+  with chunks 0 { when 'arg cancel unit }
 }
 
 func range_step _ _ 0 = yield 'arg
···
 }
 
 func filter predicate it = do() {
-  with it!()
+  with it!() {
     when 'next(val) if predicate val resume yield 'next(val)
     when 'next(_) resume unit
-    else yield
+  }
 }
 
 test "iterator filter" {
···
 }
 
 func map f it = do() {
-  with it!()
+  with it!() {
     when 'next(val) resume yield 'next(f val)
-    else yield
+  }
 }
 
 test "iterator map" {
···
 }
 
 func flat_map f it = do() {
-  with it!()
+  with it!() {
     when 'next(val) then {
       let inner = f val
       inner!()
       become unit
     }
-    else yield
+  }
 }
 
 test "iterator flat_map" {
···
 
 func scan f a it = do() {
   let mut state = a
-  with it!()
+  with it!() {
     when 'next(val) then {
       state = f state val
       become yield 'next(state)
     }
-    else yield
+  }
 }
 
 test "iterator scan" {
···
 
 func fold f a it =
   let mut state = a,
-  with it!(); state
+  with it!(); state {
     when 'next(val) then {
       state = f state val
       become unit
     }
-    else yield
+  }
 
 test "iterator fold" {
   assert fold (:) 0 <| range 1 5 == ((((0:1):2):3):4):5
···
 func reduce f it =
   let mut state = 'none,
   with
-      it!();
-      match state {
-        case 'some(v) then v
-        else yield 'mia
-      }
+    it!();
+    match state {
+      case 'some(v) then v
+      else yield 'mia
+    }
+  {
     when 'next(val) then {
       state = match state {
         case 'some(prev) then 'some(f prev val)
···
       }
       become unit
     }
-    else yield
+  }
 
 test "iterator reduce" {
   assert reduce (:) <| range 1 5 == (((1:2):3):4):5
-  assert with reduce (:) <| rangex 0 0 when 'mia cancel true else cancel false
+  assert with reduce (:) <| rangex 0 0 { when 'mia cancel true else cancel false }
 }
 
 func sum it = fold (+) 0 it
···
 }
 
 func any predicate it = 
-  with it!(); false
+  with it!(); false {
     when 'next(val) then {
       if predicate val {
         return true
       }
       become unit
     }
-    else yield
+  }
 
 test "iterator any" {
   assert any ((==) 2) <| range 1 3
···
 }
 
 func all predicate it = 
-  with it!(); true
+  with it!(); true {
     when 'next(val) then {
       if !(predicate val) {
         return false
       }
       become unit
     }
-    else yield
+  }
 
 test "iterator all" {
   assert !(all (fn x. x < 2) <| range 1 3)
···
 
 func enumerate it = do() {
   let mut i = 0
-  with it!()
+  with it!() {
     when 'next(v) then {
       let j = i
       i += 1
       become yield 'next(j:v)
     }
-    else yield
+  }
 }
 
 test "iterator enumerate" {
···
 }
 
 func find p it = 
-  with it!(); yield 'mia
+  with it!(); yield 'mia {
     when 'next(v) then {
       if p v {
         return v
       }
       become unit
     }
-    else yield
+  }
 
 test "iterator find" {
   assert find ((==) 4) <| range 3 5 == 4
-  assert with find ((==) 4) <| range 1 3 when 'mia cancel true else cancel false
+  assert with find ((==) 4) <| range 1 3 { when 'mia cancel true else cancel false }
 }
 
 func choose 0 _ = do() yield 'next([])
···
   assert collect <| choose 0 [1, 2, 3] == [[]]
 }
 
-func for_each f it = with it!(); unit
-  when 'next(v) then {
-    f v
-    become unit
+func for_each f it =
+  with it!(); unit {
+    when 'next(v) then {
+      f v
+      become unit
+    }
   }
-  else yield
 
 test "iterator for_each" {
   let arr = []

trilogy/src/stdlib/parsec.tri

···
 func run_parser parser input =
   let len = core::length input,
   let mut pos = 0,
-  let result = with parser!()
+  let result = with parser!() {
     when 'eof if pos == len resume true
     when 'eof resume false
     when 'pos resume pos
···
       pos += 1
       become unit
     }
-    else yield,
+  },
   result : core::slice pos len input
 
 ## Parses the parser as a single atomic unit, without consuming any of the input on failure.
 func atomic parser = do() {
   let pos = yield 'pos
-  return with apply parser
+  return with apply parser {
     when 'reject(_) and rej then {
       yield 'reset(pos)
       yield rej
     }
-    else yield
+  }
 }
 
 ## Transform the output value of a parser without parsing any more input.
···
 ## Attempt a parser, returning 'some(result) if it succeeds. If it fails,
 ## returns 'none without consuming any input.
 func option parser = do()
-  with 'some(apply <| atomic parser)
+  with 'some(apply <| atomic parser) {
     when 'reject(_) cancel 'none
-    else yield
+  }
 
 ## Attempt each of the list of parsers. Returns the value of the first
 ## parser that succeeds.
 func choice [] = do() yield 'reject("choice had no options")
 func choice [parser, ..rest] = do () {
-  return with apply <| atomic parser
-    when 'reject(err) cancel with apply <| choice rest
+  return with apply <| atomic parser {
+    when 'reject(err) cancel with apply <| choice rest {
       when 'reject("choice had no options") then {
         yield 'reject(err)
         end
···
         yield 'reject("${err}, or ${errs}")
         end
       }
-      else yield
-    else yield
+    }
+  }
 }
 
 ## Applies the parser as many times as possible, returning an array of
 ## the parsed results.
 func many parser = do() {
-  let result = with apply <| atomic parser
+  let result = with apply <| atomic parser {
     when 'reject(_) then { return [] }
-    else yield
+  }
   return [result, ..apply <| many parser]
 }
 
···
 
 test "parsec digit" {
   assert parse digit "123" == '1'
-  assert with parse digit "A"; false when 'reject(_) cancel true else cancel false
+  assert with parse digit "A"; false { when 'reject(_) cancel true else cancel false }
 }
 
 ## A parser for any base-16 digit.
···
 test "parsec hex_digit" {
   assert parse hex_digit "123" == '1'
   assert parse hex_digit "abc" == 'a'
-  assert with parse hex_digit "Z"; false when 'reject(_) cancel true else cancel false
+  assert with parse hex_digit "Z"; false { when 'reject(_) cancel true else cancel false }
 }
 
 ## Parses a base-10 integer from a string, returning the value as a number. A leading `-` sign
···
 
 test "parsec letter" {
   assert parse letter "a" == 'a'
-  assert with parse letter "1"; false when 'reject(_) cancel true else cancel false
+  assert with parse letter "1"; false { when 'reject(_) cancel true else cancel false }
 }
 
 ## A parser for any ASCII whitespace.
···
 
 test "parsec whitespace" {
   assert parse whitespace " " == ' '
-  assert with parse whitespace "1"; false when 'reject(_) cancel true else cancel false
+  assert with parse whitespace "1"; false { when 'reject(_) cancel true else cancel false }
 }
 
 ## A parser for any word (a sequence of word characters `[A-Za-z0-9_]`).

trilogy/src/stdlib/record.tri

···
 
 func collect iterator =
   let record = {||},
-  with (iterator!(); record)
+  with (iterator!(); record) {
     when 'next(key:val) then {
       record.key = val
       become unit
     }
-    else yield
+  }
 
 test "record collect" {
   let iterator = do() {

trilogy/src/stdlib/set.tri

···
 
 func collect iterator =
   let set = [||],
-  with (iterator!(); set)
+  with (iterator!(); set) {
     when 'next(val) then {
       push!(set, val)
       become unit
     }
-    else yield
+  }
 
 test "set collect" {
   let iterator = do() {

trilogy/src/stdlib/string.tri

···
   assert slice 1 2 "123" == "2"
   assert slice 1 1 "123" == ""
   assert slice 1 3 "123" == "23"
-  assert with (slice (-1) 2 "123"; false)
-    when 'arg cancel true
-    else yield
-  assert with (slice 2 1 "123"; false)
-    when 'arg cancel true
-    else yield
-  assert with (slice 0 5 "123"; false)
-    when 'mia cancel true
-    else yield
-  assert with (slice 5 5 "123"; false)
-    when 'mia cancel true
-    else yield
+  assert with (slice (-1) 2 "123"; false) { when 'arg cancel true }
+  assert with (slice 2 1 "123"; false) { when 'arg cancel true }
+  assert with (slice 0 5 "123"; false) { when 'mia cancel true }
+  assert with (slice 5 5 "123"; false) { when 'mia cancel true }
 }
 
 func take n (str and typeof 'string) =
···
   assert take 2 "123" == "12"
   assert take 3 "123" == "123"
   assert take 12 "123" == "123"
-  assert with (take (-1) "123"; false)
-    when 'arg cancel true
-    else yield
+  assert with (take (-1) "123"; false) { when 'arg cancel true }
 }
 
 func skip n (str and typeof 'string) =
···
   assert skip 2 "123" == "3"
   assert skip 3 "123" == ""
   assert skip 12 "123" == ""
-  assert with (skip (-1) "123"; false)
-    when 'arg cancel true
-    else yield
+  assert with (skip (-1) "123"; false) { when 'arg cancel true }
 }
 
 func drop n (str and typeof 'string) =
···
   assert drop 2 "123" == "1"
   assert drop 3 "123" == ""
   assert drop 12 "123" == ""
-  assert with (drop (-1) "123"; false)
-    when 'arg cancel true
-    else yield
+  assert with (drop (-1) "123"; false) { when 'arg cancel true }
 }
 
 func starts_with prefix string = take (length prefix) string == prefix
···
 
 func collect iterator =
   let mut str = "",
-  with (iterator!(); str)
+  with (iterator!(); str) {
     when 'next(val) then {
       str <>= core::to_string val
       become unit
     }
-    else yield
+  }
 
 test "string collect" {
   let string_iter = do() {