diff --git a/.travis.yml b/.travis.yml
index 163300c6fe..83fee66d88 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -116,12 +116,14 @@ matrix:
         - CXX1=g++-5
     - os: osx
       env:
+        - LLVM_VERSION="3.6.2"
         - LLVM_CONFIG="llvm-config-3.6"
         - config=debug
         - CC1=clang-3.6
         - CXX1=clang++-3.6
     - os: osx
       env:
+        - LLVM_VERSION="3.6.2"
         - LLVM_CONFIG="llvm-config-3.6"
         - config=release
         - lto=no
@@ -129,12 +131,14 @@ matrix:
         - CXX1=clang++-3.6
     - os: osx
       env:
+        - LLVM_VERSION="3.7.1"
         - LLVM_CONFIG="llvm-config-3.7"
         - config=debug
         - CC1=clang-3.7
         - CXX1=clang++-3.7
     - os: osx
       env:
+        - LLVM_VERSION="3.7.1"
         - LLVM_CONFIG="llvm-config-3.7"
         - config=release
         - lto=no
@@ -142,30 +146,34 @@ matrix:
         - CXX1=clang++-3.7
     - os: osx
       env:
+        - LLVM_VERSION="3.8.1"
         - LLVM_CONFIG="llvm-config-3.8"
         - config=debug
         - CC1=clang-3.8
         - CXX1=clang++-3.8
     - os: osx
       env:
+        - LLVM_VERSION="3.8.1"
         - LLVM_CONFIG="llvm-config-3.8"
         - config=release
         - lto=no
         - CC1=clang-3.8
         - CXX1=clang++-3.8
-    # LLVM 3.9 can be enabled for OSX once Homebrew supports it.
-    #- os: osx
-    #  env:
-    #    - LLVM_CONFIG="llvm-config-3.9"
-    #    - config=debug
-    #    - CC1=clang-3.9
-    #    - CXX1=clang++-3.9
-    #- os: osx
-    #  env:
-    #    - LLVM_CONFIG="llvm-config-3.9"
-    #    - config=release
-    #    - CC1=clang-3.9
-    #    - CXX1=clang++-3.9
+    - os: osx
+      env:
+        - LLVM_VERSION="3.9.0"
+        - LLVM_CONFIG="llvm-config-3.9"
+        - config=debug
+        - CC1=clang-3.9
+        - CXX1=clang++-3.9
+    - os: osx
+      env:
+        - LLVM_VERSION="3.9.0"
+        - LLVM_CONFIG="llvm-config-3.9"
+        - config=release
+        - lto=no
+        - CC1=clang-3.9
+        - CXX1=clang++-3.9
 
 
 rvm:
@@ -208,7 +216,28 @@ install:
     then
       brew update;
       brew install gmp; brew link --overwrite gmp;
-      brew install llvm36 llvm37 llvm38 pcre2 libressl;
+      if [ "${LLVM_VERSION}" = "3.6.2" ];
+      then
+        brew install llvm36;
+      fi;
+      if [ "${LLVM_VERSION}" = "3.7.1" ];
+      then
+        brew install llvm37;
+      fi;
+      if [ "${LLVM_VERSION}" = "3.8.1" ];
+      then
+        brew install llvm38;
+      fi;
+      if [ "${LLVM_VERSION}" = "3.9.0" ];
+      then
+        brew install llvm;
+        brew link --overwrite --force llvm;
+        mkdir llvmsym;
+        ln -s `which llvm-config` llvmsym/llvm-config-3.9;
+        ln -s `which clang++` llvmsym/clang++-3.9;
+        export PATH=llvmsym/:$PATH;
+      fi;
+      brew install pcre2 libressl;
     fi;
 
 script:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7809d96b1f..2c3c5dad3a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,30 @@
 
 All notable changes to the Pony compiler and standard library will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/) and [Keep a CHANGELOG](http://keepachangelog.com/).
 
+## [0.9.0] - 2016-11-11
+
+### Fixed
+
+- Stop leaking memory during serialization (issue #1413) (PR #1414)
+- Fixed compiler segmentation fault when given an invalid target triple. (PR #1406)
+- Fixed error message when no type arguments are given (issue #1396) (PR #1397)
+- Fixed compiler assert failure when constructor is called on type intersection (issue #1398) (PR #1401)
+- Fix compiler assert fail on circular type inference error (issue #1334) (PR #1339)
+- Performance problem in the scheduler queue when running with many threads (issue #1404)
+- Invalid name mangling in generated C headers (issue #1377)
+
+### Added
+
+- Method chaining (RFC #25) (PR #1411)
+- Iter class methods `all`, `any`, `collect`, `count`, `find`, `last`, `nth`, `run`, `skip`, `skip_while`, `take`, `take_while` (issue #1370)
+- Output of `ponyc --version` shows C compiler used to build pony (issue #1245)
+- Makefile detects `llvmconfig39` in addition to `llvm-config-3.9` (#1379)
+- LLVM 3.9 support
+
+### Changed
+
+- Changed lambda literal syntax to be more concise (issue #1391) (PR #1400)
+
 ## [0.8.0] - 2016-10-27
 
 ### Fixed
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 11052e14be..6601b9737e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -44,7 +44,14 @@ Before issuing a pull request we ask that you squash all your commits into a sin
 
 If you aren't sure how to squash multiple commits into one, Steve Klabnik wrote [a handy guide](http://blog.steveklabnik.com/posts/2012-11-08-how-to-squash-commits-in-a-github-pull-request) that you can refer to.
 
-We keep a [CHANGELOG](CHANGELOG.md) of all software changes with behavioural effects in ponyc. If your PR includes such changes (rather than say a documentation update), please make sure that as part of PR, you have also updated the CHANGELOG. The entries in the CHANGELOG are in time-ascending order, so please add your change description to the bottom of the appropriate section ("Fixed", "Added", or "Changed") of the "unreleased" log.
+We keep a [CHANGELOG](CHANGELOG.md) of all software changes with behavioural effects in ponyc. If your PR includes such changes (rather than say a documentation update), a Pony team member will do the following before merging it, so that the PR will be automatically added to the CHANGELOG:
+
+* Ensure that the ticket is tagged with one or more appropriate "changelog - *" labels - each label corresponds to a section of the changelog where this change will be automatically mentioned.
+* Ensure that the ticket title is appropriate - the title will be used as the summary of the change, so it should be appropriately formatted, including a ticket reference if the PR is a fix to an existing bug ticket.
+  * For example, an appropriate title for a PR that fixes a bug reported in issue ticket #98 might look like:
+  * *Fixed compiler crash related to tuple recovery (issue #98)*
+
+Once those conditions are met, the PR can be merged, and an automated system will immediately add the entry to the changelog. Keeping the changelog entries out of the file changes in the PR helps to avoid conflicts and other administrative headaches when many PRs are in progress.
 
 Documentation Formatting
 ---------------
diff --git a/Makefile b/Makefile
index 074ce388d3..209bdf8366 100644
--- a/Makefile
+++ b/Makefile
@@ -98,6 +98,7 @@ AR_FLAGS ?= rcs
 ALL_CFLAGS = -std=gnu11 -fexceptions \
   -DPONY_VERSION=\"$(tag)\" -DLLVM_VERSION=\"$(llvm_version)\" \
   -DPONY_COMPILER=\"$(CC)\" -DPONY_ARCH=\"$(arch)\" \
+  -DBUILD_COMPILER=\"$(compiler_version)\" \
   -DPONY_BUILD_CONFIG=\"$(config)\"
 ALL_CXXFLAGS = -std=gnu++11 -fno-rtti
 
@@ -186,6 +187,10 @@ ifndef LLVM_CONFIG
     LLVM_CONFIG = llvm-config-3.6
     LLVM_LINK = llvm-link-3.6
     LLVM_OPT = opt-3.6
+  else ifneq (,$(shell which llvm-config39 2> /dev/null))
+    LLVM_CONFIG = llvm-config39
+    LLVM_LINK = llvm-link39
+    LLVM_OPT = opt39
   else ifneq (,$(shell which llvm-config38 2> /dev/null))
     LLVM_CONFIG = llvm-config38
     LLVM_LINK = llvm-link38
@@ -215,6 +220,17 @@ endif
 
 llvm_version := $(shell $(LLVM_CONFIG) --version)
 
+ifeq ($(llvm_version),3.6.2)
+else ifeq ($(llvm_version),3.7.1)
+else ifeq ($(llvm_version),3.8.1)
+else ifeq ($(llvm_version),3.9.0)
+else
+  $(warning WARNING: Unsupported LLVM version: $(llvm_version))
+  $(warning Please use LLVM 3.6.2, 3.7.1, 3.8.1, or 3.9.0)
+endif
+
+compiler_version := "$(shell $(CC) --version | sed -n 1p)"
+
 ifeq ($(runtime-bitcode),yes)
   ifeq (,$(shell $(CC) -v 2>&1 | grep clang))
     $(error Compiling the runtime as a bitcode file requires clang)
@@ -575,7 +591,11 @@ $(foreach target,$(targets),$(eval $(call EXPAND_COMMAND,$(target))))
 
 
 define EXPAND_INSTALL
+ifeq ($(OSTYPE),linux)
+install: libponyc libponyrt libponyrt-pic ponyc
+else
 install: libponyc libponyrt ponyc
+endif
 	@mkdir -p $(destdir)/bin
 	@mkdir -p $(destdir)/lib
 	@mkdir -p $(destdir)/include/pony/detail
@@ -642,6 +662,7 @@ test-examples: all
 	@rm examples1
 
 test-ci: all
+	@$(PONY_BUILD_DIR)/ponyc --version
 	@$(PONY_BUILD_DIR)/libponyc.tests
 	@$(PONY_BUILD_DIR)/libponyrt.tests
 	@$(PONY_BUILD_DIR)/ponyc -d -s --verify packages/stdlib
diff --git a/README.md b/README.md
index 447edab90c..547a51ae24 100644
--- a/README.md
+++ b/README.md
@@ -63,9 +63,9 @@ If you're using `docker-machine` instead of native docker, make sure you aren't
 
 ## Linux using an RPM package (via Bintray)
 
-For Red Hat, CentOS, or Fedora Linux, the `master` and `release` branches are packaged and availabe on Bintray ([pony-language/ponyc-rpm](https://bintray.com/pony-language/ponyc-rpm)).
+For Red Hat, CentOS, Oracle Linux, or Fedora Linux, the `master` and `release` branches are packaged and available on Bintray ([pony-language/ponyc-rpm](https://bintray.com/pony-language/ponyc-rpm)).
 
-To install  release builds via Yum:
+To install release builds via Yum:
 ```bash
 wget https://bintray.com/pony-language/ponyc-rpm/rpm -O bintray-pony-language-ponyc-rpm.repo
 sudo mv bintray-pony-language-ponyc-rpm.repo /etc/yum.repos.d/
@@ -80,7 +80,7 @@ yum install ponyc-master
 
 ## Linux using a DEB package (via Bintray)
 
-For Ubuntu or Debian Linux, the `master` and `release` branches are packaged and availabe on Bintray ([pony-language/ponyc-debian](https://bintray.com/pony-language/ponyc-debian)).
+For Ubuntu or Debian Linux, the `master` and `release` branches are packaged and available on Bintray ([pony-language/ponyc-debian](https://bintray.com/pony-language/ponyc-debian)).
 
 To install release builds via Apt:
 
@@ -98,7 +98,7 @@ sudo apt-get install ponyc-master
 
 ## Windows using ZIP (via Bintray)
 
-For Windows, the `master` and `release` branches are packaged and availabe on Bintray ([pony-language/ponyc-win](https://bintray.com/pony-language/ponyc-win)):
+For Windows, the `master` and `release` branches are packaged and available on Bintray ([pony-language/ponyc-win](https://bintray.com/pony-language/ponyc-win)):
 
 ```powershell
 Invoke-WebRequest -Uri https://dl.bintray.com/pony-language/ponyc-win/ponyc-VERSION.zip -UseBasicParsing -OutFile ponyc-VERSION.zip
@@ -144,7 +144,7 @@ Pony requires one of the following versions of LLVM:
 - 3.6.2
 - 3.7.1
 - 3.8.1
-- 3.9.0 (unsupported on OSX at the moment)
+- 3.9.0
 
 Compiling Pony is only possible on x86 and ARM (either 32 or 64 bits).
 
diff --git a/VERSION b/VERSION
index a3df0a6959..ac39a106c4 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.8.0
+0.9.0
diff --git a/examples/delegates/main.pony b/examples/delegates/main.pony
index f318ee26c3..258467dcaa 100644
--- a/examples/delegates/main.pony
+++ b/examples/delegates/main.pony
@@ -4,37 +4,37 @@ Demonstrate the basic use of delegates in pony
 use "time"
 
 trait Wombat
-  fun box battle_call() : String val =>
+  fun box battle_call(): String val =>
     "Huzzah!"
 
 class SimpleWombat is Wombat
 
 class KungFuWombat is Wombat
-  fun box battle_call() : String val =>
+  fun box battle_call(): String val =>
     "Bonzai!"
 
 trait Drone
-  fun box battle_call() : String val =>
+  fun box battle_call(): String val =>
     "Beep Boop!"
 
-class DroneWombat is ( Drone & Wombat)
-  fun box battle_call() : String val =>
+class DroneWombat is (Drone & Wombat)
+  fun box battle_call(): String val =>
     "Beep boop Huzzah!"
 
 actor Main is Wombat
-  let wombatness : Wombat delegate Wombat
+  let wombatness: Wombat delegate Wombat
 
-  new create(env : Env) =>
+  new create(env: Env) =>
     let x = Time.nanos() % 3
 
-    wombatness = match x
-    | 0 => SimpleWombat
-    | 1 => DroneWombat
-    | 2 => KungFuWombat
-    else
-      SimpleWombat
-    end
+    wombatness =
+      match x
+      | 0 => SimpleWombat
+      | 1 => DroneWombat
+      | 2 => KungFuWombat
+      else
+        SimpleWombat
+      end
 
     env.out.print("Welcome to Wombat Combat!")
     env.out.print("Battle cry: " + this.battle_call())
-
diff --git a/examples/echo/echo.pony b/examples/echo/echo.pony
index b2c49389ce..3d60ca8e24 100644
--- a/examples/echo/echo.pony
+++ b/examples/echo/echo.pony
@@ -29,7 +29,7 @@ class Listener is TCPListenNotify
     _out.print("couldn't listen")
     listen.close()
 
-  fun ref connected(listen: TCPListener ref) : TCPConnectionNotify iso^ =>
+  fun ref connected(listen: TCPListener ref): TCPConnectionNotify iso^ =>
     Server(_out)
 
 class Server is TCPConnectionNotify
diff --git a/examples/lambda/lambda.pony b/examples/lambda/lambda.pony
index 1bf58c46d5..e7e00f280f 100644
--- a/examples/lambda/lambda.pony
+++ b/examples/lambda/lambda.pony
@@ -5,15 +5,15 @@ Simple example of creating and calling a lambda function.
 actor Main
   new create(env: Env) =>
     // First let's pass an add function.
-    let x = f(lambda(a: U32, b: U32): U32 => a + b end, 6)
+    let x = f({(a: U32, b: U32): U32 => a + b }, 6)
     env.out.print("Add: " + x.string())
 
     // Now a multiply.
-    let y = f(lambda(a: U32, b: U32): U32 => a * b end, 6)
+    let y = f({(a: U32, b: U32): U32 => a * b }, 6)
     env.out.print("Mult: " + y.string())
 
     // And finally a lambda that raises an error.
-    let z = f(lambda(a: U32, b: U32): U32 ? => error end, 6)
+    let z = f({(a: U32, b: U32): U32 ? => error }, 6)
     env.out.print("Error: " + z.string())
 
   fun f(fn: {(U32, U32): U32 ?} val, x: U32): U32 =>
diff --git a/examples/mixed/main.pony b/examples/mixed/main.pony
index d55a161ce4..f935f29c24 100644
--- a/examples/mixed/main.pony
+++ b/examples/mixed/main.pony
@@ -20,7 +20,7 @@ actor Worker
         false
       end
 
-  fun ref factorize(bigint: U64) : Array[U64] =>
+  fun ref factorize(bigint: U64): Array[U64] =>
     var factors = Array[U64](2)
 
     if bigint <= 3 then
@@ -81,7 +81,7 @@ actor Ring
       Worker(_env)
     end
 
-  fun tag spawn_ring(env: Env, size: U32, pass': U32) : Ring =>
+  fun tag spawn_ring(env: Env, size: U32, pass': U32): Ring =>
     var next: Ring = this
 
     for i in Range[U32](0, size) do
diff --git a/examples/producer-consumer/consumer.pony b/examples/producer-consumer/consumer.pony
index e98becb923..77f4063c32 100644
--- a/examples/producer-consumer/consumer.pony
+++ b/examples/producer-consumer/consumer.pony
@@ -17,5 +17,3 @@ actor Consumer
   be consuming(product: Product) =>
     _out.print("**Consumer** Consuming product " + product.id.string())
     _quantity_to_consume = _quantity_to_consume -1
-
-
diff --git a/examples/yield/main.pony b/examples/yield/main.pony
index 8ed9b4a33c..4e3721fe5e 100644
--- a/examples/yield/main.pony
+++ b/examples/yield/main.pony
@@ -48,27 +48,27 @@ class StopWatch
   """
   A simple stopwatch class for performance micro-benchmarking
   """
-  var _s : U64 = 0
+  var _s: U64 = 0
 
-  fun ref start() : StopWatch =>
+  fun ref start(): StopWatch =>
     _s = Time.nanos()
     this
 
-  fun delta() : U64 =>
+  fun delta(): U64 =>
     Time.nanos() - _s
 
 actor LonelyPony
   """
   A simple manifestation of the lonely pony problem
   """
-  var _env : Env
-  let _sw : StopWatch = StopWatch
-  var _alive : Bool = true
-  var _debug : Bool = false
-  var _m : U64
-  var _n : U64
-
-  new create(env : Env, debug : Bool = false, n : U64 = 0) =>
+  var _env: Env
+  let _sw: StopWatch = StopWatch
+  var _alive: Bool = true
+  var _debug: Bool = false
+  var _m: U64
+  var _n: U64
+
+  new create(env: Env, debug: Bool = false, n: U64 = 0) =>
     _env = env
     _debug = debug
     _m = n
@@ -105,13 +105,13 @@ actor InterruptiblePony
   """
   An interruptible version that avoids the lonely pony problem
   """
-  var _env : Env
-  let _sw : StopWatch = StopWatch
-  var _alive : Bool = true
-  var _debug : Bool = false
-  var _n : U64
+  var _env: Env
+  let _sw: StopWatch = StopWatch
+  var _alive: Bool = true
+  var _debug: Bool = false
+  var _n: U64
 
-  new create(env : Env, debug : Bool, n : U64 = 0) =>
+  new create(env: Env, debug: Bool, n: U64 = 0) =>
     _env = env
     _debug = debug
     _n = n
@@ -152,11 +152,11 @@ actor InterruptiblePony
     this
 
 actor PunkDemo
-  var _env : Env
-  var _alive : Bool = false
-  var _current : U8 = 0
+  var _env: Env
+  var _alive: Bool = false
+  var _current: U8 = 0
 
-  new create(env : Env) =>
+  new create(env: Env) =>
     _env = env
 
   be inc() =>
@@ -184,15 +184,15 @@ actor PunkDemo
     end
 
 actor Main
-  var _env : Env
-  new create(env : Env) =>
+  var _env: Env
+  new create(env: Env) =>
     _env = env
 
-    var punk : Bool = false
-    var lonely : Bool = false
-    var perf : U64 = 0
-    var debug : Bool = false
-    var err : Bool = false
+    var punk: Bool = false
+    var lonely: Bool = false
+    var perf: U64 = 0
+    var debug: Bool = false
+    var err: Bool = false
 
     let options = Options(env.args) +
       ("punk", "p", None) +
@@ -205,7 +205,7 @@ actor Main
       match opt
       | ("punk", None) => punk = true
       | ("lonely", None) => lonely = true
-      | ("bench", let arg : I64) => perf = arg.u64()
+      | ("bench", let arg: I64) => perf = arg.u64()
       | ("debug", None) => debug = true
       else
         err = true
diff --git a/packages/builtin/array.pony b/packages/builtin/array.pony
index e877c009a5..0f7b0931af 100644
--- a/packages/builtin/array.pony
+++ b/packages/builtin/array.pony
@@ -374,7 +374,7 @@ class Array[A] is Seq[A]
 
   fun find(value: A!, offset: USize = 0, nth: USize = 0,
     predicate: {(box->A!, box->A!): Bool} val =
-      lambda(l: box->A!, r: box->A!): Bool => l is r end): USize ?
+      {(l: box->A!, r: box->A!): Bool => l is r }): USize ?
   =>
     """
     Find the `nth` appearance of `value` from the beginning of the array,
@@ -403,7 +403,7 @@ class Array[A] is Seq[A]
     error
 
   fun contains(value: A!, predicate: {(box->A!, box->A!): Bool} val =
-    lambda(l: box->A!, r: box->A!): Bool => l is r end): Bool =>
+    {(l: box->A!, r: box->A!): Bool => l is r }): Bool =>
     """
     Returns true if the array contains `value`, false otherwise.
     """
@@ -420,7 +420,7 @@ class Array[A] is Seq[A]
 
   fun rfind(value: A!, offset: USize = -1, nth: USize = 0,
     predicate: {(box->A!, box->A!): Bool} val =
-      lambda(l: box->A!, r: box->A!): Bool => l is r end): USize ?
+      {(l: box->A!, r: box->A!): Bool => l is r }): USize ?
   =>
     """
     Find the `nth` appearance of `value` from the end of the array, starting at
diff --git a/packages/builtin_test/_test.pony b/packages/builtin_test/_test.pony
index e3b253ebd7..d1c5c65768 100644
--- a/packages/builtin_test/_test.pony
+++ b/packages/builtin_test/_test.pony
@@ -162,7 +162,7 @@ class iso _TestStringToBool is UnitTest
     h.assert_eq[Bool](true, "true".bool())
     h.assert_eq[Bool](true, "TRUE".bool())
 
-    h.assert_error(lambda()? => "bogus".bool() end)
+    h.assert_error({()? => "bogus".bool() })
 
 
 class iso _TestStringToFloat is UnitTest
@@ -191,9 +191,9 @@ class iso _TestStringToU8 is UnitTest
     h.assert_eq[U8](123, "0123".u8())
     h.assert_eq[U8](89, "089".u8())
 
-    h.assert_error(lambda()? => "300".u8() end, "U8 300")
-    h.assert_error(lambda()? => "30L".u8() end, "U8 30L")
-    h.assert_error(lambda()? => "-10".u8() end, "U8 -10")
+    h.assert_error({()? => "300".u8() }, "U8 300")
+    h.assert_error({()? => "30L".u8() }, "U8 30L")
+    h.assert_error({()? => "-10".u8() }, "U8 -10")
 
     h.assert_eq[U8](16, "0x10".u8())
     h.assert_eq[U8](31, "0x1F".u8())
@@ -203,10 +203,10 @@ class iso _TestStringToU8 is UnitTest
     h.assert_eq[U8](2, "0B10".u8())
     h.assert_eq[U8](0x8A, "0b1000_1010".u8())
 
-    h.assert_error(lambda()? => "1F".u8() end, "U8 1F")
-    h.assert_error(lambda()? => "0x".u8() end, "U8 0x")
-    h.assert_error(lambda()? => "0b3".u8() end, "U8 0b3")
-    h.assert_error(lambda()? => "0d4".u8() end, "U8 0d4")
+    h.assert_error({()? => "1F".u8() }, "U8 1F")
+    h.assert_error({()? => "0x".u8() }, "U8 0x")
+    h.assert_error({()? => "0b3".u8() }, "U8 0b3")
+    h.assert_error({()? => "0d4".u8() }, "U8 0d4")
 
 
 class iso _TestStringToI8 is UnitTest
@@ -222,8 +222,8 @@ class iso _TestStringToI8 is UnitTest
     h.assert_eq[I8](89, "089".i8())
     h.assert_eq[I8](-10, "-10".i8())
 
-    h.assert_error(lambda()? => "200".i8() end, "I8 200")
-    h.assert_error(lambda()? => "30L".i8() end, "I8 30L")
+    h.assert_error({()? => "200".i8() }, "I8 200")
+    h.assert_error({()? => "30L".i8() }, "I8 30L")
 
     h.assert_eq[I8](16, "0x10".i8())
     h.assert_eq[I8](31, "0x1F".i8())
@@ -234,10 +234,10 @@ class iso _TestStringToI8 is UnitTest
     h.assert_eq[I8](0x4A, "0b100_1010".i8())
     h.assert_eq[I8](-0x4A, "-0b100_1010".i8())
 
-    h.assert_error(lambda()? => "1F".i8() end, "U8 1F")
-    h.assert_error(lambda()? => "0x".i8() end, "U8 0x")
-    h.assert_error(lambda()? => "0b3".i8() end, "U8 0b3")
-    h.assert_error(lambda()? => "0d4".i8() end, "U8 0d4")
+    h.assert_error({()? => "1F".i8() }, "U8 1F")
+    h.assert_error({()? => "0x".i8() }, "U8 0x")
+    h.assert_error({()? => "0b3".i8() }, "U8 0b3")
+    h.assert_error({()? => "0d4".i8() }, "U8 0d4")
 
 
 class iso _TestStringToIntLarge is UnitTest
@@ -249,45 +249,45 @@ class iso _TestStringToIntLarge is UnitTest
   fun apply(h: TestHelper) ? =>
     h.assert_eq[U16](0, "0".u16())
     h.assert_eq[U16](123, "123".u16())
-    h.assert_error(lambda()? => "-10".u16() end, "U16 -10")
-    h.assert_error(lambda()? => "65536".u16() end, "U16 65536")
-    h.assert_error(lambda()? => "30L".u16() end, "U16 30L")
+    h.assert_error({()? => "-10".u16() }, "U16 -10")
+    h.assert_error({()? => "65536".u16() }, "U16 65536")
+    h.assert_error({()? => "30L".u16() }, "U16 30L")
 
     h.assert_eq[I16](0, "0".i16())
     h.assert_eq[I16](123, "123".i16())
     h.assert_eq[I16](-10, "-10".i16())
-    h.assert_error(lambda()? => "65536".i16() end, "I16 65536")
-    h.assert_error(lambda()? => "30L".i16() end, "I16 30L")
+    h.assert_error({()? => "65536".i16() }, "I16 65536")
+    h.assert_error({()? => "30L".i16() }, "I16 30L")
 
     h.assert_eq[U32](0, "0".u32())
     h.assert_eq[U32](123, "123".u32())
-    h.assert_error(lambda()? => "-10".u32() end, "U32 -10")
-    h.assert_error(lambda()? => "30L".u32() end, "U32 30L")
+    h.assert_error({()? => "-10".u32() }, "U32 -10")
+    h.assert_error({()? => "30L".u32() }, "U32 30L")
 
     h.assert_eq[I32](0, "0".i32())
     h.assert_eq[I32](123, "123".i32())
     h.assert_eq[I32](-10, "-10".i32())
-    h.assert_error(lambda()? => "30L".i32() end, "I32 30L")
+    h.assert_error({()? => "30L".i32() }, "I32 30L")
 
     h.assert_eq[U64](0, "0".u64())
     h.assert_eq[U64](123, "123".u64())
-    h.assert_error(lambda()? => "-10".u64() end, "U64 -10")
-    h.assert_error(lambda()? => "30L".u64() end, "U64 30L")
+    h.assert_error({()? => "-10".u64() }, "U64 -10")
+    h.assert_error({()? => "30L".u64() }, "U64 30L")
 
     h.assert_eq[I64](0, "0".i64())
     h.assert_eq[I64](123, "123".i64())
     h.assert_eq[I64](-10, "-10".i64())
-    h.assert_error(lambda()? => "30L".i64() end, "I64 30L")
+    h.assert_error({()? => "30L".i64() }, "I64 30L")
 
     h.assert_eq[U128](0, "0".u128())
     h.assert_eq[U128](123, "123".u128())
-    h.assert_error(lambda()? => "-10".u128() end, "U128 -10")
-    h.assert_error(lambda()? => "30L".u128() end, "U128 30L")
+    h.assert_error({()? => "-10".u128() }, "U128 -10")
+    h.assert_error({()? => "30L".u128() }, "U128 30L")
 
     h.assert_eq[I128](0, "0".i128())
     h.assert_eq[I128](123, "123".i128())
     h.assert_eq[I128](-10, "-10".i128())
-    h.assert_error(lambda()? => "30L".i128() end, "I128 30L")
+    h.assert_error({()? => "30L".i128() }, "I128 30L")
 
 
 class iso _TestStringLstrip is UnitTest
@@ -933,7 +933,7 @@ class iso _TestArrayInsert is UnitTest
     c.insert(2, "four")
     h.assert_array_eq[String](["one", "three", "four"], c)
 
-    h.assert_error(lambda()? => ["one", "three"].insert(3, "invalid") end)
+    h.assert_error({()? => ["one", "three"].insert(3, "invalid") })
 
 class iso _TestArrayValuesRewind is UnitTest
   """
@@ -975,41 +975,41 @@ class iso _TestArrayFind is UnitTest
     h.assert_eq[USize](1, a.find(1))
     h.assert_eq[USize](5, a.find(1 where offset = 3))
     h.assert_eq[USize](5, a.find(1 where nth = 1))
-    h.assert_error(lambda()(a)? => a.find(6) end)
+    h.assert_error({()(a)? => a.find(6) })
     h.assert_eq[USize](2, a.find(1 where
-      predicate = lambda(l: ISize, r: ISize): Bool => l > r end))
+      predicate = {(l: ISize, r: ISize): Bool => l > r }))
     h.assert_eq[USize](0, a.find(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end))
+      predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }))
     h.assert_eq[USize](3, a.find(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end,
-      nth = 1))
-    h.assert_error(lambda()(a)? => a.find(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end,
-      nth = 2) end)
+      predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }, nth = 1))
+    h.assert_error({()(a)? =>
+      a.find(0 where
+        predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }, nth = 2)
+    })
 
     h.assert_eq[USize](5, a.rfind(1))
     h.assert_eq[USize](1, a.rfind(1 where offset = 3))
     h.assert_eq[USize](1, a.rfind(1 where nth = 1))
-    h.assert_error(lambda()(a)? => a.rfind(6) end)
+    h.assert_error({()(a)? => a.rfind(6) })
     h.assert_eq[USize](4, a.rfind(1 where
-      predicate = lambda(l: ISize, r: ISize): Bool => l > r end))
+      predicate = {(l: ISize, r: ISize): Bool => l > r }))
     h.assert_eq[USize](3, a.rfind(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end))
+      predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }))
     h.assert_eq[USize](0, a.rfind(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end,
-      nth = 1))
-    h.assert_error(lambda()(a)? => a.rfind(0 where
-      predicate = lambda(l: ISize, r: ISize): Bool => (l % 3) == r end,
-      nth = 2) end)
+      predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }, nth = 1))
+    h.assert_error({()(a)? =>
+      a.rfind(0 where
+        predicate = {(l: ISize, r: ISize): Bool => (l % 3) == r }, nth = 2)
+    })
 
     var b = Array[_FindTestCls]
     let c = _FindTestCls
     b.push(c)
-    h.assert_error(lambda()(b)? => b.find(_FindTestCls) end)
+    h.assert_error({()(b)? => b.find(_FindTestCls) })
     h.assert_eq[USize](0, b.find(c))
     h.assert_eq[USize](0, b.find(_FindTestCls where
-      predicate = lambda(l: _FindTestCls box, r: _FindTestCls box): Bool =>
-        l == r end))
+      predicate = {(l: _FindTestCls box, r: _FindTestCls box): Bool => l == r }
+    ))
 
 
 class iso _TestMath128 is UnitTest
@@ -1236,7 +1236,7 @@ class iso _TestMaybePointer is UnitTest
     let a = MaybePointer[_TestStruct].none()
     h.assert_true(a.is_none())
 
-    h.assert_error(lambda()(a)? => let from_a = a() end)
+    h.assert_error({()(a)? => let from_a = a() })
 
     let s = _TestStruct
     s.i = 7
diff --git a/packages/bureaucracy/_test.pony b/packages/bureaucracy/_test.pony
index 6e06273deb..d4ff690272 100644
--- a/packages/bureaucracy/_test.pony
+++ b/packages/bureaucracy/_test.pony
@@ -31,12 +31,9 @@ class iso _TestRegistrar is UnitTest
     let r = Registrar
     r("test") = _TestDisposable(h)
 
-    r[_TestDisposable]("test").next[None](
-      recover
-        lambda(value: _TestDisposable)(h) =>
-          value.dispose()
-        end
-      end)
+    r[_TestDisposable]("test").next[None]({(value: _TestDisposable)(h) =>
+      value.dispose()
+    } iso)
 
 actor _TestDisposable
   let _h: TestHelper
diff --git a/packages/collections/_test.pony b/packages/collections/_test.pony
index 354b2ec5e6..c732af845b 100644
--- a/packages/collections/_test.pony
+++ b/packages/collections/_test.pony
@@ -147,7 +147,7 @@ class iso _TestMapUpsert is UnitTest
 
   fun apply(h: TestHelper) ? =>
     let x: Map[U32, U64] = Map[U32,U64]
-    let f = lambda(x: U64, y: U64): U64 => x + y end
+    let f = {(x: U64, y: U64): U64 => x + y }
     x.upsert(1, 5, f)
     h.assert_eq[U64](5, x(1))
     x.upsert(1, 3, f)
@@ -160,7 +160,7 @@ class iso _TestMapUpsert is UnitTest
     h.assert_eq[U64](15, x(1))
 
     let x2: Map[U32, String] = Map[U32,String]
-    let g = lambda(x: String, y: String): String => x + ", " + y end
+    let g = {(x: String, y: String): String => x + ", " + y }
     x2.upsert(1, "1", g)
     h.assert_eq[String]("1", x2(1))
     x2.upsert(1, "2", g)
@@ -176,7 +176,7 @@ class iso _TestMapUpsert is UnitTest
     let prealloc: USize = 6
     let expected_initial_size: USize = (prealloc * 4) / 3
     let x3: Map[U32, U64] = Map[U32,U64](prealloc)
-    let f' = lambda(x: U64, y: U64): U64 => x + y end
+    let f' = {(x: U64, y: U64): U64 => x + y }
     h.assert_eq[USize](expected_initial_size, x3.space())
     h.assert_eq[U64](1, x3.upsert(1, 1, f'))
     h.assert_eq[U64](1, x3.upsert(2, 1, f'))
@@ -202,15 +202,15 @@ class iso _TestRing is UnitTest
 
     a.push(4).push(5)
 
-    h.assert_error(lambda()(a)? => a(0) end, "Read ring 0")
-    h.assert_error(lambda()(a)? => a(1) end, "Read ring 1")
+    h.assert_error({()(a)? => a(0) }, "Read ring 0")
+    h.assert_error({()(a)? => a(1) }, "Read ring 1")
 
     h.assert_eq[U64](a(2), 2)
     h.assert_eq[U64](a(3), 3)
     h.assert_eq[U64](a(4), 4)
     h.assert_eq[U64](a(5), 5)
 
-    h.assert_error(lambda()(a)? => a(6) end, "Read ring 6")
+    h.assert_error({()(a)? => a(6) }, "Read ring 6")
 
 class iso _TestListsMap is UnitTest
   fun name(): String => "collections/Lists/map()"
@@ -219,7 +219,7 @@ class iso _TestListsMap is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2)
 
-    let f = lambda(a: U32): U32 => a * 2 end
+    let f = {(a: U32): U32 => a * 2 }
     let c = a.map[U32](f)
 
     h.assert_eq[USize](c.size(), 3)
@@ -234,7 +234,7 @@ class iso _TestListsFlatMap is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2)
 
-    let f = lambda(a: U32): List[U32] => List[U32].push(a).push(a * 2) end
+    let f = {(a: U32): List[U32] => List[U32].push(a).push(a * 2) }
     let c = a.flat_map[U32](f)
 
     h.assert_eq[USize](c.size(), 6)
@@ -252,7 +252,7 @@ class iso _TestListsFilter is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3)
 
-    let f = lambda(a: U32): Bool => a > 1 end
+    let f = {(a: U32): Bool => a > 1 }
     let b = a.filter(f)
 
     h.assert_eq[USize](b.size(), 2)
@@ -266,12 +266,12 @@ class iso _TestListsFold is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3)
 
-    let f = lambda(acc: U32, x: U32): U32 => acc + x end
+    let f = {(acc: U32, x: U32): U32 => acc + x }
     let value = a.fold[U32](f, 0)
 
     h.assert_eq[U32](value, 6)
 
-    let g = lambda(acc: List[U32], x: U32): List[U32] => acc.push(x * 2) end
+    let g = {(acc: List[U32], x: U32): List[U32] => acc.push(x * 2) }
     let resList = a.fold[List[U32]](g, List[U32])
 
     h.assert_eq[USize](resList.size(), 4)
@@ -287,9 +287,9 @@ class iso _TestListsEvery is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3)
 
-    let f = lambda(x: U32): Bool => x < 4 end
-    let g = lambda(x: U32): Bool => x < 3 end
-    let z = lambda(x: U32): Bool => x < 0 end
+    let f = {(x: U32): Bool => x < 4 }
+    let g = {(x: U32): Bool => x < 3 }
+    let z = {(x: U32): Bool => x < 0 }
     let lessThan4 = a.every(f)
     let lessThan3 = a.every(g)
     let lessThan0 = a.every(z)
@@ -309,9 +309,9 @@ class iso _TestListsExists is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3)
 
-    let f = lambda(x: U32): Bool => x > 2 end
-    let g = lambda(x: U32): Bool => x >= 0 end
-    let z = lambda(x: U32): Bool => x < 0 end
+    let f = {(x: U32): Bool => x > 2 }
+    let g = {(x: U32): Bool => x >= 0 }
+    let z = {(x: U32): Bool => x < 0 }
     let gt2 = a.exists(f)
     let gte0 = a.exists(g)
     let lt0 = a.exists(z)
@@ -331,7 +331,7 @@ class iso _TestListsPartition is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3)
 
-    let isEven = lambda(x: U32): Bool => (x % 2) == 0 end
+    let isEven = {(x: U32): Bool => (x % 2) == 0 }
     (let evens, let odds) = a.partition(isEven)
 
     h.assert_eq[USize](evens.size(), 2)
@@ -417,10 +417,10 @@ class iso _TestListsTakeWhile is UnitTest
     let a = List[U32]
     a.push(0).push(1).push(2).push(3).push(4)
 
-    let f = lambda(x: U32): Bool => x < 5 end
-    let g = lambda(x: U32): Bool => x < 4 end
-    let y = lambda(x: U32): Bool => x < 1 end
-    let z = lambda(x: U32): Bool => x < 0 end
+    let f = {(x: U32): Bool => x < 5 }
+    let g = {(x: U32): Bool => x < 4 }
+    let y = {(x: U32): Bool => x < 1 }
+    let z = {(x: U32): Bool => x < 0 }
     let b = a.take_while(f)
     let c = a.take_while(g)
     let d = a.take_while(y)
diff --git a/packages/collections/map.pony b/packages/collections/map.pony
index ef0709be5f..1f16997077 100644
--- a/packages/collections/map.pony
+++ b/packages/collections/map.pony
@@ -91,13 +91,13 @@ class HashMap[K, V, H: HashFunction[K] val]
     add 4 to the current value for key "test", which let's say is currently 2.
     We call
 
-    m.upsert("test", 4, lambda(x: I64, y: I64): I64 => x - y end)
+    m.upsert("test", 4, {(x: I64, y: I64): I64 => x - y })
 
     This changes the value associated with "test" to -2.
 
     If we have not yet added the key "new-key" to the map and we call
 
-    m.upsert("new-key", 4, lambda(x: I64, y: I64): I64 => x - y end)
+    m.upsert("new-key", 4, {(x: I64, y: I64): I64 => x - y })
 
     then "new-key" is added to the map with a value of -4.
 
diff --git a/packages/collections/persistent/_test.pony b/packages/collections/persistent/_test.pony
index 28e304dbac..90d9907cf5 100644
--- a/packages/collections/persistent/_test.pony
+++ b/packages/collections/persistent/_test.pony
@@ -75,11 +75,11 @@ class iso _TestListApply is UnitTest
     h.assert_eq[U32](l1(0), 1)
     h.assert_eq[U32](l1(1), 2)
     h.assert_eq[U32](l1(2), 3)
-    h.assert_error(lambda()(l1)? => l1(3) end)
-    h.assert_error(lambda()(l1)? => l1(4) end)
+    h.assert_error({()(l1)? => l1(3) })
+    h.assert_error({()(l1)? => l1(4) })
 
     let l2 = Lists[U32].empty()
-    h.assert_error(lambda()(l2)? => l2(0) end)
+    h.assert_error({()(l2)? => l2(0) })
 
 class iso _TestListValues is UnitTest
   fun name(): String => "collections/persistent/List/values()"
@@ -125,7 +125,7 @@ class iso _TestListMap is UnitTest
   fun name(): String => "collections/persistent/Lists/map()"
 
   fun apply(h: TestHelper) ? =>
-    let l5 = Lists[U32]([1, 2, 3]).map[U32](lambda(x: U32): U32 => x * 2 end)
+    let l5 = Lists[U32]([1, 2, 3]).map[U32]({(x: U32): U32 => x * 2 })
     h.assert_true(Lists[U32].eq(l5, Lists[U32]([2,4,6])))
 
     true
@@ -134,7 +134,7 @@ class iso _TestListFlatMap is UnitTest
   fun name(): String => "collections/persistent/Lists/flat_map()"
 
   fun apply(h: TestHelper) ? =>
-    let f = lambda(x: U32): List[U32] => Lists[U32]([x - 1, x, x + 1]) end
+    let f = {(x: U32): List[U32] => Lists[U32]([x - 1, x, x + 1]) }
     let l6 = Lists[U32]([2, 5, 8]).flat_map[U32](f)
     h.assert_true(Lists[U32].eq(l6, Lists[U32]([1,2,3,4,5,6,7,8,9])))
 
@@ -144,7 +144,7 @@ class iso _TestListFilter is UnitTest
   fun name(): String => "collections/persistent/Lists/filter()"
 
   fun apply(h: TestHelper) ? =>
-    let is_even = lambda(x: U32): Bool => (x % 2) == 0 end
+    let is_even = {(x: U32): Bool => (x % 2) == 0 }
     let l7 = Lists[U32]([1,2,3,4,5,6,7,8]).filter(is_even)
     h.assert_true(Lists[U32].eq(l7, Lists[U32]([2,4,6,8])))
 
@@ -154,12 +154,12 @@ class iso _TestListFold is UnitTest
   fun name(): String => "collections/persistent/Lists/fold()"
 
   fun apply(h: TestHelper) ? =>
-    let add = lambda(acc: U32, x: U32): U32 => acc + x end
+    let add = {(acc: U32, x: U32): U32 => acc + x }
     let value = Lists[U32]([1,2,3]).fold[U32](add, 0)
     h.assert_eq[U32](value, 6)
 
     let doubleAndPrepend =
-      lambda(acc: List[U32], x: U32): List[U32] => acc.prepend(x * 2) end
+      {(acc: List[U32], x: U32): List[U32] => acc.prepend(x * 2) }
     let l8 =
       Lists[U32]([1,2,3]).fold[List[U32]](doubleAndPrepend, Lists[U32].empty())
     h.assert_true(Lists[U32].eq(l8, Lists[U32]([6,4,2])))
@@ -170,7 +170,7 @@ class iso _TestListEveryExists is UnitTest
   fun name(): String => "collections/persistent/Lists/every()exists()"
 
   fun apply(h: TestHelper) =>
-    let is_even = lambda(x: U32): Bool => (x % 2) == 0 end
+    let is_even = {(x: U32): Bool => (x % 2) == 0 }
     let l9 = Lists[U32]([4,2,10])
     let l10 = Lists[U32]([1,1,3])
     let l11 = Lists[U32]([1,1,2])
@@ -193,7 +193,7 @@ class iso _TestListPartition is UnitTest
   fun name(): String => "collections/persistent/Lists/partition()"
 
   fun apply(h: TestHelper) ? =>
-    let is_even = lambda(x: U32): Bool => (x % 2) == 0 end
+    let is_even = {(x: U32): Bool => (x % 2) == 0 }
     let l = Lists[U32]([1,2,3,4,5,6])
     (let hits, let misses) = l.partition(is_even)
     h.assert_true(Lists[U32].eq(hits, Lists[U32]([2,4,6])))
@@ -217,7 +217,7 @@ class iso _TestListDropWhile is UnitTest
   fun name(): String => "collections/persistent/List/drop_while()"
 
   fun apply(h: TestHelper) ? =>
-    let is_even = lambda(x: U32): Bool => (x % 2) == 0 end
+    let is_even = {(x: U32): Bool => (x % 2) == 0 }
     let l = Lists[U32]([4,2,6,1,3,4,6])
     let empty = Lists[U32].empty()
     h.assert_true(Lists[U32].eq(l.drop_while(is_even), Lists[U32]([1,3,4,6])))
@@ -240,7 +240,7 @@ class iso _TestListTakeWhile is UnitTest
   fun name(): String => "collections/persistent/List/take_while()"
 
   fun apply(h: TestHelper) ? =>
-    let is_even = lambda(x: U32): Bool => (x % 2) == 0 end
+    let is_even = {(x: U32): Bool => (x % 2) == 0 }
     let l = Lists[U32]([4,2,6,1,3,4,6])
     let empty = Lists[U32].empty()
     h.assert_true(Lists[U32].eq(l.take_while(is_even), Lists[U32]([4,2,6])))
@@ -253,7 +253,7 @@ class iso _TestMap is UnitTest
 
   fun apply(h: TestHelper) =>
     let m1: Map[String,U32] = Maps.empty[String,U32]()
-    h.assert_error(lambda()(m1)? => m1("a") end)
+    h.assert_error({()(m1)? => m1("a") })
     let s1 = m1.size()
     h.assert_eq[USize](s1, 0)
 
@@ -281,17 +281,17 @@ class iso _TestMap is UnitTest
       h.assert_eq[U32](m7("b"), 3)
       h.assert_eq[U32](m7("a"), 10)
       let m8 = m7.remove("a")
-      h.assert_error(lambda()(m8 = m8)? => m8("a") end)
+      h.assert_error({()(m8 = m8)? => m8("a") })
       h.assert_eq[U32](m8("b"), 3)
       h.assert_eq[U32](m8("d"), 4)
       h.assert_eq[U32](m8("e"), 5)
       let m9 = m7.remove("e")
-      h.assert_error(lambda()(m9 = m9)? => m9("e") end)
+      h.assert_error({()(m9 = m9)? => m9("e") })
       h.assert_eq[U32](m9("b"), 3)
       h.assert_eq[U32](m9("d"), 4)
       let m10 = m9.remove("b").remove("d")
-      h.assert_error(lambda()(m10 = m10)? => m10("b") end)
-      h.assert_error(lambda()(m10 = m10)? => m10("d") end)
+      h.assert_error({()(m10 = m10)? => m10("b") })
+      h.assert_error({()(m10 = m10)? => m10("d") })
     else
       h.complete(false)
     end
diff --git a/packages/collections/persistent/list.pony b/packages/collections/persistent/list.pony
index a43a3ace8c..4cc414a4a3 100644
--- a/packages/collections/persistent/list.pony
+++ b/packages/collections/persistent/list.pony
@@ -21,7 +21,7 @@ h.assert_eq[U32](l4_head, 1)
 h.assert_true(Lists[U32].eq(l4, Lists[U32]([1, 2, 3])))
 h.assert_true(Lists[U32].eq(l4_tail, Lists[U32]([2, 3])))
 
-let doubled = l4.map[U32](lambda(x: U32): U32 => x * 2 end)
+let doubled = l4.map[U32]({(x: U32): U32 => x * 2 })
 
 h.assert_true(Lists[U32].eq(doubled, Lists[U32]([2, 4, 6])))
 
diff --git a/packages/files/_test.pony b/packages/files/_test.pony
index ca7dcb3a47..2076646d21 100644
--- a/packages/files/_test.pony
+++ b/packages/files/_test.pony
@@ -58,7 +58,7 @@ class iso _TestWalk is UnitTest
       h, ["a/1", "a/2", "b", "c/3", "c/4", "d/5", "d/6"])
     try
       top.walk(
-        lambda(dir: FilePath, entries: Array[String] ref)(p = top.path, h) =>
+        {(dir: FilePath, entries: Array[String] ref)(p = top.path, h) =>
           if dir.path == p then
             h.assert_array_eq_unordered[String](["b", "c", "a", "d"], entries)
           elseif dir.path.at("a", -1) then
@@ -70,7 +70,7 @@ class iso _TestWalk is UnitTest
           else
             h.fail("Unexpected dir: " + dir.path)
           end
-        end)
+        })
     then
       h.assert_true(top.remove())
     end
diff --git a/packages/glob/_test.pony b/packages/glob/_test.pony
index 4ee0e40633..94f264afd8 100644
--- a/packages/glob/_test.pony
+++ b/packages/glob/_test.pony
@@ -140,20 +140,18 @@ class iso _TestIGlob is UnitTest
   fun apply(h: TestHelper) ? =>
     let top = _FileHelper.make_files(h, ["a/1", "a/2", "b", "c/1", "c/4"])
     try
-      Glob.iglob(
-        top, "*/1",
-        lambda(f: FilePath, matches: Array[String])(top, h) =>
-          try
-            match matches(0)
-            | "a" => h.assert_eq[String](Path.rel(top.path, f.path), "a/1")
-            | "c" => h.assert_eq[String](Path.rel(top.path, f.path), "c/1")
-            else
-              error
-            end
+      Glob.iglob(top, "*/1", {(f: FilePath, matches: Array[String])(top, h) =>
+        try
+          match matches(0)
+          | "a" => h.assert_eq[String](Path.rel(top.path, f.path), "a/1")
+          | "c" => h.assert_eq[String](Path.rel(top.path, f.path), "c/1")
           else
-              h.fail("Unexpected match: " + f.path)
+            error
           end
-        end)
+        else
+            h.fail("Unexpected match: " + f.path)
+        end
+      })
     then
       h.assert_true(top.remove())
     end
diff --git a/packages/glob/glob.pony b/packages/glob/glob.pony
index d2198c65ee..e40df7c5df 100644
--- a/packages/glob/glob.pony
+++ b/packages/glob/glob.pony
@@ -149,9 +149,9 @@ primitive Glob
     let res = recover ref Array[FilePath] end
     iglob(
       root_path, pattern,
-      lambda ref(path: FilePath, match_groups: Array[String])(res) =>
+      {ref(path: FilePath, match_groups: Array[String])(res) =>
         res.push(path)
-      end)
+      })
     res
 
   fun _apply_glob_to_walk(
diff --git a/packages/itertools/_test.pony b/packages/itertools/_test.pony
index 089c0deb47..e813380af3 100644
--- a/packages/itertools/_test.pony
+++ b/packages/itertools/_test.pony
@@ -13,12 +13,23 @@ actor Main is TestList
     test(_TestMapFn)
     test(_TestFilter)
 
+    test(_TestIterAll)
+    test(_TestIterAny)
+    test(_TestIterCollect)
+    test(_TestIterCount)
     test(_TestIterCycle)
     test(_TestIterEnum)
     test(_TestIterFilter)
+    test(_TestIterFind)
     test(_TestIterFold)
+    test(_TestIterLast)
     test(_TestIterMap)
+    test(_TestIterNth)
+    test(_TestIterRun)
+    test(_TestIterSkip)
+    test(_TestIterSkipWhile)
     test(_TestIterTake)
+    test(_TestIterTakeWhile)
     test(_TestIterZip)
 
 class iso _TestChain is UnitTest
@@ -193,7 +204,7 @@ class iso _TestMapFn is UnitTest
     let expected = ["ab", "bb", "cb"]
     let actual = Array[String]
 
-    let fn = lambda (x: String): String => x + "b" end
+    let fn = {(x: String): String => x + "b" }
     for x in MapFn[String, String](input.values(), fn) do
       actual.push(x)
     end
@@ -210,7 +221,7 @@ class iso _TestFilter is UnitTest
     let expected = ["c", "f", "g"]
     let actual = Array[String]
 
-    let fn1 = lambda (x: String): Bool => x.size() == 1 end
+    let fn1 = {(x: String): Bool => x.size() == 1 }
     for x in Filter[String](input1.values(), fn1) do
       actual.push(x)
     end
@@ -218,7 +229,7 @@ class iso _TestFilter is UnitTest
     h.assert_array_eq[String](actual, expected)
     actual.clear()
 
-    let fn2 = lambda (x: String): Bool => x.size() == 1 end
+    let fn2 = {(x: String): Bool => x.size() == 1 }
     for x in Filter[String](input2.values(), fn2) do
       actual.push(x)
     end
@@ -226,13 +237,56 @@ class iso _TestFilter is UnitTest
     h.assert_array_eq[String](actual, expected)
     actual.clear()
 
-    let fn3 = lambda (x: String): Bool => x.size() == 1 end
+    let fn3 = {(x: String): Bool => x.size() == 1 }
     for x in Filter[String](input3.values(), fn3) do
       actual.push(x)
     end
 
     h.assert_array_eq[String](actual, expected)
 
+class iso _TestIterAll is UnitTest
+  fun name(): String => "itertools/Iter.all"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as I64: 1, 3, 6, 7, 9]
+    let is_positive = {(n: I64): Bool => n > 0 }
+    h.assert_true(Iter[I64](input.values()).all(is_positive))
+    input(2) = -6
+    h.assert_false(Iter[I64](input.values()).all(is_positive))
+
+class iso _TestIterAny is UnitTest
+  fun name(): String => "itertools/Iter.any"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as I64: -1, -3, 6, -7, -9]
+    let is_positive = {(n: I64): Bool => n > 0 }
+    h.assert_true(Iter[I64](input.values()).any(is_positive))
+    input(2) = -6
+    h.assert_false(Iter[I64](input.values()).any(is_positive))
+
+class iso _TestIterCollect is UnitTest
+  fun name(): String => "itertools/Iter.collect"
+
+  fun apply(h: TestHelper) =>
+    let input = [as I64: 1, 2, 3, 4, 5]
+    h.assert_array_eq[I64](
+      input,
+      Iter[I64](input.values()).collect(Array[I64]))
+
+class iso _TestIterCount is UnitTest
+  fun name(): String => "itertools/Iter.count"
+
+  fun apply(h: TestHelper) =>
+    let input1 = [as I64: 1, 2, 3, 4, 5]
+    h.assert_eq[USize](
+      input1.size(),
+      Iter[I64](input1.values()).count())
+
+    let input2 = Array[I64]
+    h.assert_eq[USize](
+      input2.size(),
+      Iter[I64](input2.values()).count())
+
 class iso _TestIterCycle is UnitTest
   fun name(): String => "itertools/Iter.cycle"
 
@@ -286,7 +340,7 @@ class iso _TestIterFilter is UnitTest
     let expected = ["c", "f", "g"]
     let actual = Array[String]
 
-    let fn1 = lambda (x: String): Bool => x.size() == 1 end
+    let fn1 = {(x: String): Bool => x.size() == 1 }
     for x in Iter[String](input1.values()).filter(fn1) do
       actual.push(x)
     end
@@ -294,7 +348,7 @@ class iso _TestIterFilter is UnitTest
     h.assert_array_eq[String](actual, expected)
     actual.clear()
 
-    let fn2 = lambda (x: String): Bool => x.size() == 1 end
+    let fn2 = {(x: String): Bool => x.size() == 1 }
     for x in Iter[String](input2.values()).filter(fn2) do
       actual.push(x)
     end
@@ -302,26 +356,64 @@ class iso _TestIterFilter is UnitTest
     h.assert_array_eq[String](actual, expected)
     actual.clear()
 
-    let fn3 = lambda (x: String): Bool => x.size() == 1 end
+    let fn3 = {(x: String): Bool => x.size() == 1 }
     for x in Iter[String](input3.values()).filter(fn3) do
       actual.push(x)
     end
 
     h.assert_array_eq[String](actual, expected)
 
+class iso _TestIterFind is UnitTest
+  fun name(): String => "itertools/Iter.find"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as I64: 1, 2, 3, -4, 5]
+    h.assert_error({()(input) ? =>
+      Iter[I64](input.values()).find({(x: I64): Bool => x == 0 })
+    })
+    let ltzero = {(x: I64): Bool => x < 0 }
+    h.assert_eq[I64](
+      -4,
+      Iter[I64](input.values()).find(ltzero))
+    h.assert_error({()(input, ltzero) ? =>
+      Iter[I64](input.values()).find(ltzero, 2)
+    })
+    h.assert_eq[I64](
+      5,
+      Iter[I64](input.values()).find({(x: I64): Bool => x > 0 }, 4))
+
 class iso _TestIterFold is UnitTest
   fun name(): String => "itertools/Iter.fold"
 
   fun apply(h: TestHelper) ? =>
     let ns = [as I64: 1, 2, 3, 4, 5, 6]
-    let fn = lambda(sum: I64, n: I64): I64 => sum + n end
+    let fn = {(sum: I64, n: I64): I64 => sum + n }
     let sum = Iter[I64](ns.values()).fold[I64](fn, 0)
     h.assert_eq[I64](sum, 21)
 
-    let err = lambda(acc: I64, x: I64): I64 ? => error end
-    h.assert_error(lambda()(ns, err) ? =>
+    let err = {(acc: I64, x: I64): I64 ? => error }
+    h.assert_error({()(ns, err) ? =>
       Iter[I64](ns.values()).fold[I64](err, 0)
-    end)
+    })
+
+class iso _TestIterLast is UnitTest
+  fun name(): String => "itertools/Iter.last"
+
+  fun apply(h: TestHelper) ? =>
+    let input1 = Array[I64]
+    h.assert_error({()(input1) ? => Iter[I64](input1.values()).last() })
+    let input2 =[as I64: 1]
+    h.assert_eq[I64](
+      1,
+      Iter[I64](input2.values()).last())
+    let input3 = [as I64: 1, 2]
+    h.assert_eq[I64](
+      2,
+      Iter[I64](input3.values()).last())
+    let input4 = [as I64: 1, 2, 3]
+    h.assert_eq[I64](
+      3,
+      Iter[I64](input4.values()).last())
 
 class iso _TestIterMap is UnitTest
   fun name(): String => "itertools/Iter.map"
@@ -331,13 +423,80 @@ class iso _TestIterMap is UnitTest
     let expected = ["ab", "bb", "cb"]
     let actual = Array[String]
 
-    let fn = lambda (x: String): String => x + "b" end
+    let fn = { (x: String): String => x + "b" }
     for x in Iter[String](input.values()).map[String](fn) do
       actual.push(x)
     end
 
     h.assert_array_eq[String](actual, expected)
 
+class iso _TestIterNth is UnitTest
+  fun name(): String => "itertools/Iter.nth"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as USize: 1, 2, 3]
+    h.assert_eq[USize](
+      1,
+      Iter[USize](input.values()).nth(1))
+    h.assert_eq[USize](
+      2,
+      Iter[USize](input.values()).nth(2))
+    h.assert_eq[USize](
+      3,
+      Iter[USize](input.values()).nth(3))
+    h.assert_error({()(input) ? => Iter[USize](input.values()).nth(4) })
+
+class iso _TestIterRun is UnitTest
+  fun name(): String => "itertools/Iter.run"
+
+  fun apply(h: TestHelper) =>
+    h.expect_action("1")
+    h.expect_action("2")
+    h.expect_action("3")
+    h.expect_action("error")
+    
+    let xs = [as I64: 1, 2, 3]
+
+    h.long_test(100_000_000)
+    
+    Iter[I64](xs.values())
+      .map[None]({(x: I64)(h) => h.complete_action(x.string()) })
+      .run()
+
+    Iter[I64](object ref is Iterator[I64]
+      fun ref has_next(): Bool => true
+      fun ref next(): I64 ? => error
+    end).run({()(h) => h.complete_action("error") })
+
+class iso _TestIterSkip is UnitTest
+  fun name(): String => "itertools/Iter.skip"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as I64: 1]
+    h.assert_error({()(input) ? =>
+      Iter[I64](input.values()).skip(1).next()
+    })
+    input.push(2)
+    h.assert_eq[I64](
+      2,
+      Iter[I64](input.values()).skip(1).next())
+    input.push(3)
+    h.assert_eq[I64](
+      3,
+      Iter[I64](input.values()).skip(2).next())
+
+class iso _TestIterSkipWhile is UnitTest
+  fun name(): String => "itertools/Iter.skip_while"
+
+  fun apply(h: TestHelper) ? =>
+    let input = [as I64: -1, 0, 1, 2, 3]
+    h.assert_eq[I64](
+      1,
+      Iter[I64](input.values()).skip_while({(x: I64): Bool => x <= 0 }).next())
+    h.assert_eq[I64](
+      -1,
+      Iter[I64](input.values()).skip_while({(x: I64): Bool => x < -2 }).next())
+
 class iso _TestIterTake is UnitTest
   fun name(): String => "itertools/Iter.take"
 
@@ -353,6 +512,24 @@ class iso _TestIterTake is UnitTest
 
     h.assert_array_eq[String](expected, actual)
 
+class iso _TestIterTakeWhile is UnitTest
+  fun name(): String => "itertools/Iter.take_while"
+
+  fun apply(h: TestHelper) =>
+    let input = [as I64: -1, 0, 1, 2, 3]
+    h.assert_array_eq[I64](
+      [as I64: -1, 0],
+      Iter[I64](input.values()).take_while({(x: I64): Bool => x < 1 })
+        .collect(Array[I64]))
+    h.assert_array_eq[I64](
+      input,
+      Iter[I64](input.values()).take_while({(x: I64): Bool => x < 4 })
+        .collect(Array[I64]))
+    h.assert_array_eq[I64](
+      Array[I64],
+      Iter[I64](input.values()).take_while({(x: I64): Bool ? => error })
+        .collect(Array[I64]))
+
 class iso _TestIterZip is UnitTest
   fun name(): String => "itertools/Iter.zip"
 
@@ -386,7 +563,6 @@ class iso _TestIterZip is UnitTest
     end
 
     h.assert_array_eq[String](expected1, actual1)
-
     h.assert_array_eq[U32](expected2, actual2)
     h.assert_array_eq[F32](expected3, actual3)
     h.assert_array_eq[I32](expected4, actual4)
diff --git a/packages/itertools/filter.pony b/packages/itertools/filter.pony
index 60a746ba30..1530fe2e8b 100644
--- a/packages/itertools/filter.pony
+++ b/packages/itertools/filter.pony
@@ -14,7 +14,7 @@ class Filter[A] is Iterator[A]
 
   actor Main
     new create(env: Env) =>
-      let fn = lambda (s: String): Bool => x.size() > 3 end
+      let fn = {(s: String): Bool => x.size() > 3 }
       for x in Filter[String](env.args.slice(1).values(), fn) do
         env.out.print(x)
       end
diff --git a/packages/itertools/iter.pony b/packages/itertools/iter.pony
index 1ba81e4dcc..5fc1753006 100644
--- a/packages/itertools/iter.pony
+++ b/packages/itertools/iter.pony
@@ -18,15 +18,121 @@ class Iter[A] is Iterator[A]
     """
     Take an iterator of iterators and work through them, returning the
     items of the first one, then the second one, and so on.
+
+    ## Example
+    ```pony
+    let xs = [as I64: 1, 2].values()
+    let ys = [as I64: 3, 4].values()
+
+    Iter[I64].chain([xs, ys].values())
+    ```
+    `1 2 3 4`
     """
     _iter = Chain[A](outer_iterator)
 
-  fun ref cycle(): Iter[A!] =>
+  fun ref all(f: {(A!): Bool ?} box): Bool =>
+    """
+    Return false if at least one value of the iterator fails to match the
+    predicate `f`. This method short-circuits at the first value where the
+    predicate returns false, otherwise true is returned.
+
+    ## Examples
+
+    ```pony
+    Iter[I64]([as I64: 2, 4, 6].values())
+      .all({(x: I64): Bool => (x % 2) == 0 })
+    ```
+    `true`
+
+    ```pony
+    Iter[I64]([as I64: 2, 3, 4].values())
+      .all({(x: I64): Bool => (x % 2) == 0 })
+    ```
+    `false`
+    """
+    for x in _iter do
+      if not (try f(x) else false end) then
+        return false
+      end
+    end
+    true
+
+  fun ref any(f: {(A!): Bool ?} box): Bool =>
+    """
+    Return true if at least one value of the iterator matches the predicate 
+    `f`. This method short-circuits at the first value where the predicate
+    returns true, otherwise false is returned.
+
+    ## Examples
+
+    ```pony
+    Iter[I64]([as I64: 2, 4, 6].values())
+      .any({(x: I64): Bool => (x % 2) == 1 })
+    ```
+    `false`
+
+    ```pony
+    Iter[I64]([as I64: 2, 3, 4].values())
+      .any({(x: I64): Bool => (x % 2) == 1 })
+    ```
+    `true`
+    """
+    for x in _iter do
+      if try f(x) else false end then
+        return true
+      end
+    end
+    false
+
+  fun ref collect[B: Seq[A!] = Array[A!]](coll: B): B^ =>
+    """
+    Push each value from the iterator into the collection `coll`.
+    
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .collect(Array[I64](3))
+    ```
+    `[1, 2, 3]`
+    """
+    for x in _iter do
+      coll.push(x)
+    end
+    coll
+
+  fun ref count(): USize =>
+    """
+    Return the number of values in the iterator.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .count()
+    ```
+    `3`
+    """
+    var c: USize = 0
+    for x in _iter do
+      c = c + 1
+    end
+    c
+
+  fun ref cycle(): Iter[A!]^ =>
     """
     Repeatedly cycle through the values from the iterator.
 
     WARNING: The values returned by the original iterator are cached, so
     the input iterator should be finite.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .cycle()
+    ```
+    `1 2 3 1 2 3 1 2 3 ...`
     """
     let store = Array[A!]
     Iter[A!](object is Iterator[A!]
@@ -60,6 +166,14 @@ class Iter[A] is Iterator[A]
     """
     An iterator which yields the current iteration count as well as the next
     value from the iterator.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .enum()
+    ```
+    `(0, 1) (1, 2) (2, 3)`
     """
     Iter[(B, A)](object is Iterator[(B, A)]
       let _iter: Iterator[A] = _iter
@@ -73,13 +187,20 @@ class Iter[A] is Iterator[A]
 
     end)
 
-  fun ref filter(fn: {(A!): Bool ?} box): Iter[A]^ =>
+  fun ref filter(f: {(A!): Bool ?} box): Iter[A]^ =>
     """
-    Take a predicate function and return an iterator that only returns items
-    that match the predicate.
+    Return an iterator that only returns items that match the predicate `f`.
+    
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4, 5, 6].values())
+      .filter({(x: I64): Bool => (x % 2) == 0 })
+    ```
+    `2 4 6`
     """
     Iter[A](object is Iterator[A]
-      let _fn: {(A!): Bool ?} box = fn
+      let _fn: {(A!): Bool ?} box = f
       let _iter: Iterator[A] = _iter
       var _next: (A! | _None) = _None
 
@@ -125,19 +246,83 @@ class Iter[A] is Iterator[A]
         end
     end)
 
+  fun ref find(f: {(A!): Bool ?} box, n: USize = 1): A ? =>
+    """
+    Return the nth value in the iterator that satisfies the predicate `f`.
+    
+    ## Examples
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .find({(x: I64): Bool => (x % 2) == 0 })
+    ```
+    `2`
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4].values())
+      .find({(x: I64): Bool => (x % 2) == 0 }, 2)
+    ```
+    `4`
+    """
+    var c = n
+    for x in _iter do
+      if try f(x) else false end then
+        if c == 1 then
+          return consume x as A
+        else
+          c = c - 1
+        end
+      end
+    end
+    error
+
   fun ref fold[B](f: {(B, A!): B^ ?} box, acc: B): B^ ? =>
     """
     Apply a function to every element, producing an accumulated value.
+    
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .fold[I64]({(x: I64, sum: I64): I64 => sum + x }, 0)
+    ```
+    `6`
     """
     if not _iter.has_next() then
       return acc
     end
     fold[B](f, f(consume acc, _iter.next()))
 
-  fun ref map[B](f: {(A!): B ?} box): Iter[B] =>
+  fun ref last(): A ? =>
+    """
+    Return the last value of the iterator.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .last()
+    ```
+    `3`
+    """
+    var l = _iter.next()
+    while _iter.has_next() do
+      l = _iter.next()
+    end
+    consume l as A
+
+  fun ref map[B](f: {(A!): B ?} box): Iter[B]^ =>
     """
     Return an iterator where each item's value is the application of the given
     function to the value in the original iterator.
+    
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .map[I64]({(x: I64): I64 => x * x })
+    ```
+    `1 4 9`
     """
     Iter[B](object is Iterator[B]
       let _iter: Iterator[A] = _iter
@@ -158,9 +343,119 @@ class Iter[A] is Iterator[A]
         end
     end)
 
-  fun ref take(n: USize): Iter[A] =>
+  fun ref nth(n: USize): A ? =>
+    """
+    Return the nth value of the iterator.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .nth(2)
+    ```
+    `2`
+    """
+    var c = n
+    while c > 1 do
+      _iter.next()
+      c = c - 1
+    end
+    _iter.next()
+
+  fun ref run(on_error: {()} box = {() => None }) =>
     """
-    Only return a specified number of items.
+    Iterate through the values of the iterator without a for loop. The
+    function `on_error` will be called if the iterator's `has_next` method
+    returns true but its `next` method trows an error.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3].values())
+      .map[None]({(x: I64)(env) => env.out.print(x.string()) })
+      .run()
+    ```
+    ```
+    1
+    2
+    3
+    ```
+    """
+    if not _iter.has_next() then return end
+    try 
+      _iter.next() 
+      run(on_error)
+    else
+      on_error()
+    end
+
+  fun ref skip(n: USize): Iter[A]^ =>
+    """
+    Skip the first n values of the iterator.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4, 5, 6].values())
+      .skip(3)
+    ```
+    `4 5 6`
+    """
+    var c = n
+    try
+      while c > 0 do
+        _iter.next()
+        c = c - 1
+      end
+    end
+    this
+
+  fun ref skip_while(f: {(A!): Bool ?} box): Iter[A]^ =>
+    """
+    Skip values of the iterator while the predicate `f` returns true.
+    
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4, 5, 6].values())
+      .skip_while({(x: I64): Bool => x < 4 })
+    ```
+    `4 5 6`
+    """
+    Iter[A](object is Iterator[A]
+      let _f: {(A!): Bool ?} box = f
+      let _iter: Iterator[A] = _iter
+      var _done: Bool = false
+
+      fun ref has_next(): Bool =>
+        _iter.has_next()
+
+      fun ref next(): A ? =>
+        if _done then
+          _iter.next()
+        else
+          let x = _iter.next()
+          if try _f(x) else false end then
+            next()
+          else
+            _done = true
+            consume x as A
+          end
+        end
+
+    end)
+
+  fun ref take(n: USize): Iter[A]^ =>
+    """
+    Return an iterator for the first n elements.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4, 5, 6].values())
+      .take(3)
+    ```
+    `1 2 3`
     """
     Iter[A](object is Iterator[A]
       var _countdown: USize = n
@@ -174,12 +469,47 @@ class Iter[A] is Iterator[A]
         _iter.next()
     end)
 
+  fun ref take_while(f: {(A!): Bool ?} box): Iter[A]^ =>
+    """
+    Return an iterator that returns values while the predicate `f` returns
+    true.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2, 3, 4, 5, 6].values())
+      .take_while({(x: I64): Bool => x < 4 })
+    ```
+    `1 2 3`
+    """
+    let pred = object
+      let _f: {(A!): Bool ?} box = f
+      var _taking: Bool = true
+
+      fun apply(a: A!): Bool ? =>
+        if _taking then
+          _f(a)
+        else
+          false
+        end
+
+    end
+    filter(pred)
+
   fun ref zip[B](i2: Iterator[B]): Iter[(A, B)]^ =>
     """
     Zip two iterators together so that each call to next() results in the
     a tuple with the next value of the first iterator and the next value
     of the second iterator. The number of items returned is the minimum of
     the number of items returned by the two iterators.
+
+    ## Example
+
+    ```pony
+    Iter[I64]([as I64: 1, 2].values())
+      .zip[I64]([as I64: 3, 4].values())
+    ```
+    `(1, 3) (2, 4)`
     """
     Iter[(A, B)](object is Iterator[(A, B)]
       let _i1: Iterator[A] = _iter
diff --git a/packages/itertools/itertools.pony b/packages/itertools/itertools.pony
index d5d9930bd8..29ea23ca79 100644
--- a/packages/itertools/itertools.pony
+++ b/packages/itertools/itertools.pony
@@ -1,10 +1,63 @@
 """
 # Itertools Package
 
-Provide a set of classes for doing useful things with
-iterators. Inspired by Python's itertools library.
+The itertools package provides a set of classes for doing useful things with
+iterators. It is Inspired by Python's itertools library, Rust's Iterator, and
+Elixir's Enum and Stream.
 
-Chain -- chain together two iterators
+## Iter
+
+The Iter class wraps iterators so that additional methods may be applied to it.
+Some methods, such as fold and collect, run through the underlying iterator in 
+order to return a result. Others, such as map and filter, are lazy. This means
+that they return another Iter so that the resulting values are computed one by
+one as needed. Lazy methods return Iter types.
+
+For example, the following code creates an Iter from the values of an array
+containing the numbers 1 through 5, increments each number by one, filters out
+any odd numbers, and prints the rest.
+
+```pony
+let xs = Iter[I64]([as I64: 1, 2, 3, 4, 5].values())
+  .map[I64]({(x: I64): I64 => x + 1 })
+  .filter({(x: I64): Bool => (x % 2) == 0 })
+  .map[None]({(x: I64)(env) => env.out.print(x.string()) })
+```
+
+This will result in an iterator that prints the numbers 2, 4, and 6. However,
+due to the lazy nature of the map and filter, no iteration has actually occured
+and nothing will be printed. One solution to this would be to loop over the
+resulting Iter as so:
+
+```pony
+for x in xs do
+  None
+end
+```
+
+This will trigger the iteration and print out the values 2, 4, and 6. This is
+where the `run` method comes in handy by doing the iteration without the need
+for a loop. So the final code would be as follows:
+
+```pony
+Iter[I64]([as I64: 1, 2, 3, 4, 5].values())
+  .map[I64]({(x: I64): I64 => x + 1 })
+  .filter({(x: I64): Bool => (x % 2) == 0 })
+  .map[None]({(x: I64)(env) => env.out.print(x.string()) })
+  .run()
+```
+
+Output:
+
+```
+2
+4
+6
+```
+
+## Other Classes
+
+Chain -- chain together two or more iterators
 
 Limit -- return only the specified number of itmes from the given
 iterator
@@ -21,4 +74,5 @@ the given iterator
 
 Filter -- create an iterator that only returns items that match a
 predicate
+
 """
diff --git a/packages/itertools/map_fn.pony b/packages/itertools/map_fn.pony
index 1213f36d73..be52ee38ee 100644
--- a/packages/itertools/map_fn.pony
+++ b/packages/itertools/map_fn.pony
@@ -13,7 +13,7 @@ class MapFn[A, B] is Iterator[B]
 
   actor Main
     new create(env: Env) =>
-      let fn = lambda (s: String): I32 => try s.i32() * 2 else 0 end end
+      let fn = {(s: String): I32 => try s.i32() * 2 else 0 end }
       for x in MapFn[String, I32](env.args.slice(1).values(), fn) do
         env.out.print(x.string())
       end
diff --git a/packages/json/_test.pony b/packages/json/_test.pony
index aa977ae480..c7db1721b2 100644
--- a/packages/json/_test.pony
+++ b/packages/json/_test.pony
@@ -41,9 +41,9 @@ class iso _TestParseBasic is UnitTest
     doc.parse(" true   ")
     h.assert_eq[Bool](true, doc.data as Bool)
 
-    h.assert_error(lambda()? => JsonDoc.parse("") end)
-    h.assert_error(lambda()? => JsonDoc.parse("   ") end)
-    h.assert_error(lambda()? => JsonDoc.parse("true true") end)
+    h.assert_error({()? => JsonDoc.parse("") })
+    h.assert_error({()? => JsonDoc.parse("   ") })
+    h.assert_error({()? => JsonDoc.parse("true true") })
 
 class iso _TestParseKeyword is UnitTest
   """
@@ -63,10 +63,10 @@ class iso _TestParseKeyword is UnitTest
     doc.parse("null")
     h.assert_eq[None](None, doc.data as None)
 
-    h.assert_error(lambda()? => JsonDoc.parse("tru e") end)
-    h.assert_error(lambda()? => JsonDoc.parse("truw") end)
-    h.assert_error(lambda()? => JsonDoc.parse("truez") end)
-    h.assert_error(lambda()? => JsonDoc.parse("TRUE") end)
+    h.assert_error({()? => JsonDoc.parse("tru e") })
+    h.assert_error({()? => JsonDoc.parse("truw") })
+    h.assert_error({()? => JsonDoc.parse("truez") })
+    h.assert_error({()? => JsonDoc.parse("TRUE") })
 
 class iso _TestParseNumber is UnitTest
   """
@@ -104,11 +104,11 @@ class iso _TestParseNumber is UnitTest
     doc.parse("1.23e3")
     h.assert_eq[F64](1230, doc.data as F64)
 
-    h.assert_error(lambda()? => JsonDoc.parse("0x4") end)
-    h.assert_error(lambda()? => JsonDoc.parse("+1") end)
-    h.assert_error(lambda()? => JsonDoc.parse("1.") end)
-    h.assert_error(lambda()? => JsonDoc.parse("1.-3") end)
-    h.assert_error(lambda()? => JsonDoc.parse("1e") end)
+    h.assert_error({()? => JsonDoc.parse("0x4") })
+    h.assert_error({()? => JsonDoc.parse("+1") })
+    h.assert_error({()? => JsonDoc.parse("1.") })
+    h.assert_error({()? => JsonDoc.parse("1.-3") })
+    h.assert_error({()? => JsonDoc.parse("1e") })
 
 class iso _TestParseString is UnitTest
   """
@@ -143,13 +143,13 @@ class iso _TestParseString is UnitTest
     doc.parse(""" "Foo\uD834\uDD1Ebar" """)
     h.assert_eq[String]("Foo\U01D11Ebar", doc.data as String)
 
-    h.assert_error(lambda()? => JsonDoc.parse(""" "Foo """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "Foo\z" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "\u" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "\u37" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "\u037g" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "\uD834" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse(""" "\uDD1E" """) end)
+    h.assert_error({()? => JsonDoc.parse(""" "Foo """) })
+    h.assert_error({()? => JsonDoc.parse(""" "Foo\z" """) })
+    h.assert_error({()? => JsonDoc.parse(""" "\u" """) })
+    h.assert_error({()? => JsonDoc.parse(""" "\u37" """) })
+    h.assert_error({()? => JsonDoc.parse(""" "\u037g" """) })
+    h.assert_error({()? => JsonDoc.parse(""" "\uD834" """) })
+    h.assert_error({()? => JsonDoc.parse(""" "\uDD1E" """) })
 
 class iso _TestParseArray is UnitTest
   """
@@ -195,13 +195,13 @@ class iso _TestParseArray is UnitTest
     h.assert_eq[None](None,
       ((doc.data as JsonArray).data(1) as JsonArray).data(1) as None)
 
-    h.assert_error(lambda()? => JsonDoc.parse("[true true]") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[,]") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[true,]") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[,true]") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[true") end)
-    h.assert_error(lambda()? => JsonDoc.parse("[true,") end)
+    h.assert_error({()? => JsonDoc.parse("[true true]") })
+    h.assert_error({()? => JsonDoc.parse("[,]") })
+    h.assert_error({()? => JsonDoc.parse("[true,]") })
+    h.assert_error({()? => JsonDoc.parse("[,true]") })
+    h.assert_error({()? => JsonDoc.parse("[") })
+    h.assert_error({()? => JsonDoc.parse("[true") })
+    h.assert_error({()? => JsonDoc.parse("[true,") })
 
 class iso _TestParseObject is UnitTest
   """
@@ -247,17 +247,17 @@ class iso _TestParseObject is UnitTest
     h.assert_eq[None](None,
       ((doc.data as JsonObject).data("b") as JsonObject).data("d") as None)
 
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a": 1 "b": 2}""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("{,}") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a": true,}""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{,"a": true}""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a" """) end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a": """) end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a": true""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a": true,""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{"a" true}""") end)
-    h.assert_error(lambda()? => JsonDoc.parse("""{:true}""") end)
+    h.assert_error({()? => JsonDoc.parse("""{"a": 1 "b": 2}""") })
+    h.assert_error({()? => JsonDoc.parse("{,}") })
+    h.assert_error({()? => JsonDoc.parse("""{"a": true,}""") })
+    h.assert_error({()? => JsonDoc.parse("""{,"a": true}""") })
+    h.assert_error({()? => JsonDoc.parse("""{""") })
+    h.assert_error({()? => JsonDoc.parse("""{"a" """) })
+    h.assert_error({()? => JsonDoc.parse("""{"a": """) })
+    h.assert_error({()? => JsonDoc.parse("""{"a": true""") })
+    h.assert_error({()? => JsonDoc.parse("""{"a": true,""") })
+    h.assert_error({()? => JsonDoc.parse("""{"a" true}""") })
+    h.assert_error({()? => JsonDoc.parse("""{:true}""") })
 
 class iso _TestParseRFC1 is UnitTest
   """
diff --git a/packages/logger/_test.pony b/packages/logger/_test.pony
index 2efa0558a6..61ddfe10a2 100644
--- a/packages/logger/_test.pony
+++ b/packages/logger/_test.pony
@@ -77,7 +77,7 @@ class _TestObjectLogging is _LoggerTest[U64]
   =>
     Logger[U64](level',
       stream',
-      lambda(a: U64): String => a.string() end,
+      {(a: U64): String => a.string() },
       formatter')
 
   fun level(): LogLevel => Fine
diff --git a/packages/logger/logger.pony b/packages/logger/logger.pony
index 0add5b346b..a07125a621 100644
--- a/packages/logger/logger.pony
+++ b/packages/logger/logger.pony
@@ -67,7 +67,7 @@ actor Main
   new create(env: Env) =>
     let logger = Logger[U64](Fine,
     env.out,
-    lambda(a: U64): String => a.string() end)
+    {(a: U64): String => a.string() })
 
     logger(Error) and logger.log(U64(42))
 ```
@@ -137,7 +137,7 @@ primitive StringLogger
     out: OutStream,
     formatter: LogFormatter = DefaultLogFormatter): Logger[String]
   =>
-    Logger[String](level, out, lambda(s: String): String => s end, formatter)
+    Logger[String](level, out, {(s: String): String => s }, formatter)
 
 interface val LogFormatter
   """
diff --git a/packages/net/http/_test.pony b/packages/net/http/_test.pony
index 3c6e8d857c..c92946fd1e 100644
--- a/packages/net/http/_test.pony
+++ b/packages/net/http/_test.pony
@@ -76,9 +76,9 @@ class iso _EncodeBad is UnitTest
   fun name(): String => "net/http/URLEncode.encode_bad"
 
   fun apply(h: TestHelper) =>
-    h.assert_error(lambda()? => URLEncode.encode("%2G", URLPartUser) end)
-    h.assert_error(lambda()? => URLEncode.encode("%xx", URLPartUser) end)
-    h.assert_error(lambda()? => URLEncode.encode("%2", URLPartUser) end)
+    h.assert_error({()? => URLEncode.encode("%2G", URLPartUser) })
+    h.assert_error({()? => URLEncode.encode("%xx", URLPartUser) })
+    h.assert_error({()? => URLEncode.encode("%2", URLPartUser) })
 
 class iso _EncodeIPv6 is UnitTest
   fun name(): String => "net/http/URLEncode.encode_ipv6"
@@ -86,11 +86,11 @@ class iso _EncodeIPv6 is UnitTest
   fun apply(h: TestHelper) ? =>
     // Allowed hex digits, '.' and ':' only, between '[' and ']'.
     h.assert_eq[String]("[1::A.B]", URLEncode.encode("[1::A.B]", URLPartHost))
-    h.assert_error(lambda()? => URLEncode.encode("[G]", URLPartHost) end)
-    h.assert_error(lambda()? => URLEncode.encode("[/]", URLPartHost) end)
-    h.assert_error(lambda()? => URLEncode.encode("[%32]", URLPartHost) end)
-    h.assert_error(lambda()? => URLEncode.encode("[1]2", URLPartHost) end)
-    h.assert_error(lambda()? => URLEncode.encode("[1", URLPartHost) end)
+    h.assert_error({()? => URLEncode.encode("[G]", URLPartHost) })
+    h.assert_error({()? => URLEncode.encode("[/]", URLPartHost) })
+    h.assert_error({()? => URLEncode.encode("[%32]", URLPartHost) })
+    h.assert_error({()? => URLEncode.encode("[1]2", URLPartHost) })
+    h.assert_error({()? => URLEncode.encode("[1", URLPartHost) })
     h.assert_eq[String]("1%5D", URLEncode.encode("1]", URLPartHost))
 
 class iso _EncodeClean is UnitTest
@@ -215,9 +215,9 @@ class iso _DecodeBad is UnitTest
   fun name(): String => "net/http/URLEncode.decode_bad"
 
   fun apply(h: TestHelper) =>
-    h.assert_error(lambda()? => URLEncode.decode("%2G") end)
-    h.assert_error(lambda()? => URLEncode.decode("%xx") end)
-    h.assert_error(lambda()? => URLEncode.decode("%2") end)
+    h.assert_error({()? => URLEncode.decode("%2G") })
+    h.assert_error({()? => URLEncode.decode("%xx") })
+    h.assert_error({()? => URLEncode.decode("%2") })
 
 class iso _BuildBasic is UnitTest
   fun name(): String => "net/http/URL.build_basic"
@@ -274,20 +274,25 @@ class iso _BuildBad is UnitTest
   fun name(): String => "net/http/URL.build_bad"
 
   fun apply(h: TestHelper) =>
-    h.assert_error(lambda()? =>
-      URL.build("htt_ps://user@host.name/path#fragment") end)
+    h.assert_error({()? =>
+      URL.build("htt_ps://user@host.name/path#fragment")
+    })
 
-    h.assert_error(lambda()? =>
-      URL.build("https://[11::24_]/path") end)
+    h.assert_error({()? =>
+      URL.build("https://[11::24_]/path")
+    })
 
-    h.assert_error(lambda()? =>
-      URL.build("https://[11::24/path") end)
+    h.assert_error({()? =>
+      URL.build("https://[11::24/path")
+    })
 
-    h.assert_error(lambda()? =>
-      URL.build("https://host%2Gname/path") end)
+    h.assert_error({()? =>
+      URL.build("https://host%2Gname/path")
+    })
 
-    h.assert_error(lambda()? =>
-      URL.build("https://hostname/path%") end)
+    h.assert_error({()? =>
+      URL.build("https://hostname/path%")
+    })
 
 class iso _BuildNoEncoding is UnitTest
   fun name(): String => "net/http/URL.build_no_encoding"
@@ -305,12 +310,14 @@ class iso _Valid is UnitTest
       "https", "user", "password", "host.name", 12345, "/path", "query",
       "fragment")
 
-    h.assert_error(lambda()? =>
-      URL.valid("http://rosettacode.org/wiki/Category[Pony]") end)
+    h.assert_error({()? =>
+      URL.valid("http://rosettacode.org/wiki/Category[Pony]")
+    })
 
-    h.assert_error(lambda()? =>
+    h.assert_error({()? =>
       URL.valid("https://en.wikipedia|org/wiki/Polymorphism_" +
-        "(computer_science)#Parametric_polymorphism") end)
+        "(computer_science)#Parametric_polymorphism")
+    })
 
     _Test(h, URL.valid("http://user@host"),
       "http", "user", "", "host", 80, "/", "", "")
diff --git a/packages/net/http/payload.pony b/packages/net/http/payload.pony
index c42cd202b1..adbb203e48 100644
--- a/packages/net/http/payload.pony
+++ b/packages/net/http/payload.pony
@@ -194,8 +194,6 @@ class iso Payload
 
     list.push(proto)
     list.push(" ")
-    list.push(status.string())
-    list.push(" ")
     list.push(method)
 
     if keepalive then
diff --git a/packages/net/tcp_connection_notify.pony b/packages/net/tcp_connection_notify.pony
index 75080db82b..bd5703f933 100644
--- a/packages/net/tcp_connection_notify.pony
+++ b/packages/net/tcp_connection_notify.pony
@@ -98,4 +98,3 @@ interface TCPConnectionNotify
     `write` and `writev` again.
     """
     None
-
diff --git a/packages/ponybench/_auto_bench.pony b/packages/ponybench/_auto_bench.pony
index 8ce5ae6035..09d5315122 100644
--- a/packages/ponybench/_auto_bench.pony
+++ b/packages/ponybench/_auto_bench.pony
@@ -14,16 +14,14 @@ actor _AutoBench[A: Any #share]
     max_ops: U64 = 100_000_000
   ) =>
     _notify = notify
-    _run = recover
-      lambda(ops: U64)(notify = this, name, f) =>
-        match f
-        | let fn: {(): A ?} val =>
-          _Bench[A](notify)(name, fn, ops)
-        | let fn: {(): Promise[A] ?} val =>
-          _BenchAsync[A](notify)(name, fn, ops)
-        end
+    _run = {(ops: U64)(notify = this, name, f) =>
+      match f
+      | let fn: {(): A ?} val =>
+        _Bench[A](notify)(name, fn, ops)
+      | let fn: {(): Promise[A] ?} val =>
+        _BenchAsync[A](notify)(name, fn, ops)
       end
-    end
+    } val
     _auto_ops = _AutoOps(bench_time, max_ops)
 
   be apply(ops: U64 = 1) => _run(ops)
diff --git a/packages/ponybench/_bench_async.pony b/packages/ponybench/_bench_async.pony
index 80d9e88a83..c193437ea8 100644
--- a/packages/ponybench/_bench_async.pony
+++ b/packages/ponybench/_bench_async.pony
@@ -14,12 +14,7 @@ actor _BenchAsync[A: Any #share]
       let pn = _PromiseNotify(_notify, name, ops)
       for i in Range[U64](0, ops) do
         let p = f()
-        p.next[A](recover
-          lambda(a: A)(pn): A =>
-            pn()
-            a
-          end
-        end)
+        p.next[A]({(a: A)(pn): A => pn(); a } iso)
       end
     else
       _notify._failure(name)
diff --git a/packages/ponybench/pony_bench.pony b/packages/ponybench/pony_bench.pony
index 424553dac7..1345c6a90d 100644
--- a/packages/ponybench/pony_bench.pony
+++ b/packages/ponybench/pony_bench.pony
@@ -16,13 +16,13 @@ actor Main
     let bench = PonyBench(env)
 
     // benchmark Fib with different inputs
-    bench[USize]("fib 5", lambda(): USize => Fib(5) end)
-    bench[USize]("fib 10", lambda(): USize => Fib(10) end)
-    bench[USize]("fib 20", lambda(): USize => Fib(20) end)
-    bench[USize]("fib 40", lambda(): USize => Fib(40) end)
+    bench[USize]("fib 5", {(): USize => Fib(5) })
+    bench[USize]("fib 10", {(): USize => Fib(10) })
+    bench[USize]("fib 20", {(): USize => Fib(20) })
+    bench[USize]("fib 40", {(): USize => Fib(40) })
 
     // show what happens when a benchmark fails
-    bench[String]("fail", lambda(): String ? => error end)
+    bench[String]("fail", {(): String ? => error })
 
     // async benchmark
     bench.async[USize]("async", object iso
@@ -39,8 +39,8 @@ actor Main
     end, 1_000_000)
 
     // benchmarks with set ops
-    bench[USize]("add", lambda(): USize => 1 + 2 end, 10_000_000)
-    bench[USize]("sub", lambda(): USize => 2 - 1 end, 10_000_000)
+    bench[USize]("add", {(): USize => 1 + 2 }, 10_000_000)
+    bench[USize]("sub", {(): USize => 2 - 1 }, 10_000_000)
 
 primitive Fib
   fun apply(n: USize): USize =>
@@ -86,13 +86,9 @@ actor PonyBench
     """
     let bf = recover val
       if ops == 0 then
-        lambda()(notify = this, name, f) =>
-          _AutoBench[A](notify, name, f)()
-        end
+        {()(notify = this, name, f) => _AutoBench[A](notify, name, f)() }
       else
-        lambda()(notify = this, name, f, ops) =>
-          _Bench[A](notify)(name, f, ops)
-        end
+        {()(notify = this, name, f, ops) => _Bench[A](notify)(name, f, ops) }
       end
     end
     _bs.push((name, bf, ""))
@@ -127,12 +123,7 @@ actor PonyBench
       ts(consume t)
       try
         let p = f()
-        p.next[A](recover
-          lambda(a: A)(ts, tt): A =>
-            ts.cancel(tt)
-            a
-          end
-        end)
+        p.next[A]({(a: A)(ts, tt): A => ts.cancel(tt); a } iso)
       else
         _failure(name)
       end
@@ -140,13 +131,13 @@ actor PonyBench
 
     let bf = recover val
       if ops == 0 then
-        lambda()(notify = this, name, f) =>
+        {()(notify = this, name, f) =>
           _AutoBench[A](notify, name, f)()
-        end
+        }
       else
-        lambda()(notify = this, name, f, ops) =>
+        {()(notify = this, name, f, ops) =>
           _BenchAsync[A](notify)(name, f, ops)
-        end
+        }
       end
     end
     _bs.push((name, bf, ""))
diff --git a/packages/ponytest/pony_test.pony b/packages/ponytest/pony_test.pony
index 415cdddb72..80a02e2b3d 100644
--- a/packages/ponytest/pony_test.pony
+++ b/packages/ponytest/pony_test.pony
@@ -161,7 +161,7 @@ Test can have label. Labels are used to filter which tests are run, by setting
 command line argument `--label=[some custom label]`. It can be used to separate
 unit tests from integration tests.
 
-By default label is empty. You can set it up by overriding `label() : String`
+By default label is empty. You can set it up by overriding `label(): String`
 method in unit test.
 
 ```pony
@@ -170,7 +170,7 @@ use "ponytest"
 class iso _I8AddTest is UnitTest
   fun name(): String => "_I8AddTest"
   fun label(): String => "simple"
-  fun apply(h : TestHelper) =>
+  fun apply(h: TestHelper) =>
     h.assert_eq[I8](1, 1)
 
 ```
@@ -216,7 +216,7 @@ actor PonyTest
   var _finished: USize = 0
   var _any_found: Bool = false
   var _all_started: Bool = false
-  var _label : String = ""
+  var _label: String = ""
 
   new create(env: Env, list: TestList tag) =>
     """
diff --git a/packages/process/_test.pony b/packages/process/_test.pony
index 6142438683..adaab7fb16 100644
--- a/packages/process/_test.pony
+++ b/packages/process/_test.pony
@@ -326,4 +326,3 @@ class _ProcessClient is ProcessNotify
     _h.assert_eq[String box](_err, _d_stderr)
     _h.assert_eq[I32](_exit_code, child_exit_code)
     _h.complete(true)
-
diff --git a/packages/process/process_monitor.pony b/packages/process/process_monitor.pony
index a500574349..eb7d182f92 100644
--- a/packages/process/process_monitor.pony
+++ b/packages/process/process_monitor.pony
@@ -20,7 +20,7 @@ use "files"
 actor Main
   new create(env: Env) =>
     // create a notifier
-    let client = ProcessClient(_env)
+    let client = ProcessClient(env)
     let notifier: ProcessNotify iso = consume client
     // define the binary to run
     try
diff --git a/packages/promises/_test.pony b/packages/promises/_test.pony
index 38a942c682..9cf3b45158 100644
--- a/packages/promises/_test.pony
+++ b/packages/promises/_test.pony
@@ -18,18 +18,16 @@ class iso _TestPromise is UnitTest
   fun _test_fulfilled(h: TestHelper) =>
     h.expect_action("fulfilled")
     let p = Promise[String]
-    p.next[None](
-      recover lambda(s: String)(h) => h.complete_action(s) end end
-    )
+    p.next[None]({(s: String)(h) => h.complete_action(s) } iso)
     p("fulfilled")
 
   fun _test_rejected(h: TestHelper) =>
     h.expect_action("rejected")
     let p = Promise[String]
     p.next[String](
-      recover lambda(s: String)(h): String ? => error end end,
-      recover lambda()(h): String => "rejected" end end
+      {(s: String)(h): String ? => error } iso,
+      {()(h): String => "rejected" } iso
     ).next[None](
-      recover lambda(s: String)(h) => h.complete_action(s) end end
+      {(s: String)(h) => h.complete_action(s) } iso
     )
     p.reject()
diff --git a/packages/regex/_test.pony b/packages/regex/_test.pony
index 1ac660f517..bc7e627077 100644
--- a/packages/regex/_test.pony
+++ b/packages/regex/_test.pony
@@ -41,12 +41,12 @@ class iso _TestGroups is UnitTest
     let m2 = r("123.")
     h.assert_eq[String](m2(0), "123.")
     h.assert_eq[String](m2(1), "123")
-    h.assert_error(lambda()(m2 = m2)? => m2(2) end)
+    h.assert_error({()(m2 = m2)? => m2(2) })
     h.assert_array_eq[String](m2.groups(), ["123", ""])
 
     let m3 = r(".456")
     h.assert_eq[String](m3(0), ".456")
-    h.assert_error(lambda()(m3 = m3)? => m3(1) end)
+    h.assert_error({()(m3 = m3)? => m3(1) })
     h.assert_eq[String](m3(2), "456")
     h.assert_array_eq[String](m3.groups(), ["", "456"])
 
@@ -80,4 +80,4 @@ class iso _TestError is UnitTest
   fun name(): String => "regex/Regex.create/fails"
 
   fun apply(h: TestHelper) =>
-    h.assert_error(lambda()? => Regex("(\\d+") end)
+    h.assert_error({()? => Regex("(\\d+") })
diff --git a/packages/serialise/_test.pony b/packages/serialise/_test.pony
index 10ebc88731..63923ba687 100644
--- a/packages/serialise/_test.pony
+++ b/packages/serialise/_test.pony
@@ -205,15 +205,13 @@ class iso _TestFailures is UnitTest
     let ambient = h.env.root as AmbientAuth
     let serialise = SerialiseAuth(ambient)
 
-    h.assert_error(
-      lambda()(serialise)? =>
-        Serialised(serialise, _HasPointer)
-      end)
-
-    h.assert_error(
-      lambda()(serialise)? =>
-        Serialised(serialise, _HasActor)
-      end)
+    h.assert_error({()(serialise)? =>
+      Serialised(serialise, _HasPointer)
+    })
+
+    h.assert_error({()(serialise)? =>
+      Serialised(serialise, _HasActor)
+    })
 
 class _BoxedWord
   var f: Any val = U32(3)
diff --git a/pony.g b/pony.g
index 2b6a75aa08..e4cce72fee 100644
--- a/pony.g
+++ b/pony.g
@@ -172,6 +172,10 @@ call
   : '(' positional? named? ')'
   ;
 
+chain
+  : '.>' ID
+  ;
+
 tilde
   : '~' ID
   ;
@@ -187,6 +191,7 @@ nextatom
   | LPAREN_NEW (rawseq | '_') tuple? ')'
   | LSQUARE_NEW ('as' type ':')? rawseq (',' rawseq)* ']'
   | 'object' cap? ('is' type)? members 'end'
+  | '{' cap? ID? typeparams? ('(' | LPAREN_NEW) params? ')' lambdacaptures? (':' type)? '?'? '=>' rawseq '}' cap?
   | 'lambda' cap? ID? typeparams? ('(' | LPAREN_NEW) params? ')' lambdacaptures? (':' type)? '?'? '=>' rawseq 'end'
   | '@' (ID | STRING) typeargs? ('(' | LPAREN_NEW) positional? named? ')' '?'?
   | '__loc'
@@ -199,6 +204,7 @@ atom
   | ('(' | LPAREN_NEW) (rawseq | '_') tuple? ')'
   | ('[' | LSQUARE_NEW) ('as' type ':')? rawseq (',' rawseq)* ']'
   | 'object' cap? ('is' type)? members 'end'
+  | '{' cap? ID? typeparams? ('(' | LPAREN_NEW) params? ')' lambdacaptures? (':' type)? '?'? '=>' rawseq '}' cap?
   | 'lambda' cap? ID? typeparams? ('(' | LPAREN_NEW) params? ')' lambdacaptures? (':' type)? '?'? '=>' rawseq 'end'
   | '@' (ID | STRING) typeargs? ('(' | LPAREN_NEW) positional? named? ')' '?'?
   | '__loc'
@@ -328,6 +334,7 @@ antlr_1
 antlr_2
   : dot
   | tilde
+  | chain
   | typeargs
   | call
   ;
@@ -335,6 +342,7 @@ antlr_2
 antlr_3
   : dot
   | tilde
+  | chain
   | typeargs
   | call
   ;
diff --git a/premake5.lua b/premake5.lua
index e8e5dde29a..98633305fb 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -62,6 +62,32 @@
     return output
   end
 
+  function build_compiler()
+    local vcver = tonumber(os.getenv("_MSC_FULL_VER"))
+    if vcver == nil then
+      return "?"
+    end
+    local vcmaj = vcver / 10000000
+    local vcmin = (vcver % 10000000) / 1000000
+    local vcbld = vcver % 1000000
+    local vcday = tonumber(os.getenv("_MSC_BUILD"))
+    if vcday == nil then
+      return "?"
+    end
+
+    local osverstr = os.getenv("NTDDI_VERSION")
+    if osverstr == nil then
+      return "?"
+    end
+    local osver = tonumber(string.sub(osverstr, 3), 16)
+    local osmaj = osver / 10000000
+    local osmin = (osver % 10000000) / 100000
+    local osbld = osver % 100000
+
+    return string.format("VC++ %02d.%02d.%d.%d Windows %02d.%02d.%d",
+      vcmaj, vcmin, vcbld, vcday, osmaj, osmin, osbld)
+  end
+
   function testsuite()
     kind "ConsoleApp"
     language "C++"
@@ -95,6 +121,7 @@
       defines "DEBUG"
       defines "PONY_BUILD_CONFIG=\"debug\""
       defines { "LLVM_VERSION=\"".. llvm_version .. "\"" }
+      defines {"BUILD_COMPILER=\"" .. build_compiler() .. "\""}
       flags { "Symbols" }
 
     configuration "Release"
@@ -102,12 +129,14 @@
       objdir "build/release/obj"
       defines "PONY_BUILD_CONFIG=\"release\""
       defines { "LLVM_VERSION=\"" .. llvm_config("--version") .. "\"" }
+      defines {"BUILD_COMPILER=\"" .. build_compiler() .. "\""}
 
     configuration "Profile"
       targetdir "build/profile"
       objdir "build/profile/obj"
       defines "PONY_BUILD_CONFIG=\"profile\""
       defines { "LLVM_VERSION=\"" .. llvm_config("--version") .. "\"" }
+      defines {"BUILD_COMPILER=\"" .. build_compiler() .. "\""}
 
     configuration "Release or Profile"
       defines "NDEBUG"
diff --git a/src/libponyc/ast/lexer.c b/src/libponyc/ast/lexer.c
index b44507a60c..a2704c96f7 100644
--- a/src/libponyc/ast/lexer.c
+++ b/src/libponyc/ast/lexer.c
@@ -60,6 +60,8 @@ static const lextoken_t symbols[] =
   { "<=", TK_LE },
   { ">=", TK_GE },
 
+  { ".>", TK_CHAIN },
+
   { "{", TK_LBRACE },
   { "}", TK_RBRACE },
   { "(", TK_LPAREN },
@@ -278,6 +280,8 @@ static const lextoken_t abstract[] =
   { "newapp", TK_NEWAPP },
   { "beapp", TK_BEAPP },
   { "funapp", TK_FUNAPP },
+  { "bechain", TK_BECHAIN },
+  { "funchain", TK_FUNCHAIN },
 
   { "\\n", TK_NEWLINE },
   {NULL, (token_id)0}
diff --git a/src/libponyc/ast/parser.c b/src/libponyc/ast/parser.c
index 37944a6e2b..ad6fc9c201 100644
--- a/src/libponyc/ast/parser.c
+++ b/src/libponyc/ast/parser.c
@@ -322,10 +322,10 @@ DEF(lambdacaptures);
 
 // LAMBDA [CAP] [ID] [typeparams] (LPAREN | LPAREN_NEW) [params] RPAREN
 // [lambdacaptures] [COLON type] [QUESTION] ARROW rawseq END
-DEF(lambda);
+DEF(oldlambda);
   PRINT_INLINE();
   TOKEN(NULL, TK_LAMBDA);
-  OPT RULE("capability", cap);
+  OPT RULE("receiver capability", cap);
   OPT TOKEN("function name", TK_ID);
   OPT RULE("type parameters", typeparams);
   SKIP(NULL, TK_LPAREN, TK_LPAREN_NEW);
@@ -337,6 +337,32 @@ DEF(lambda);
   SKIP(NULL, TK_DBLARROW);
   RULE("lambda body", rawseq);
   TERMINATE("lambda expression", TK_END);
+  AST_NODE(TK_QUESTION); // Reference capability - question indicates old syntax
+  SET_CHILD_FLAG(2, AST_FLAG_PRESERVE); // Type parameters
+  SET_CHILD_FLAG(3, AST_FLAG_PRESERVE); // Parameters
+  SET_CHILD_FLAG(5, AST_FLAG_PRESERVE); // Return type
+  SET_CHILD_FLAG(7, AST_FLAG_PRESERVE); // Body
+  DONE();
+
+// LBRACE [CAP] [ID] [typeparams] (LPAREN | LPAREN_NEW) [params] RPAREN
+// [lambdacaptures] [COLON type] [QUESTION] ARROW rawseq RBRACE [CAP]
+DEF(lambda);
+  PRINT_INLINE();
+  AST_NODE(TK_LAMBDA);
+  SKIP(NULL, TK_LBRACE);
+  OPT RULE("receiver capability", cap);
+  OPT TOKEN("function name", TK_ID);
+  OPT RULE("type parameters", typeparams);
+  SKIP(NULL, TK_LPAREN, TK_LPAREN_NEW);
+  OPT RULE("parameters", params);
+  SKIP(NULL, TK_RPAREN);
+  OPT RULE("captures", lambdacaptures);
+  IF(TK_COLON, RULE("return type", type));
+  OPT TOKEN(NULL, TK_QUESTION);
+  SKIP(NULL, TK_DBLARROW);
+  RULE("lambda body", rawseq);
+  TERMINATE("lambda expression", TK_RBRACE);
+  OPT RULE("reference capability", cap);
   SET_CHILD_FLAG(2, AST_FLAG_PRESERVE); // Type parameters
   SET_CHILD_FLAG(3, AST_FLAG_PRESERVE); // Parameters
   SET_CHILD_FLAG(5, AST_FLAG_PRESERVE); // Return type
@@ -438,13 +464,13 @@ DEF(ffi);
 // ref | this | literal | tuple | array | object | lambda | ffi | location
 DEF(atom);
   RULE("value", ref, thisliteral, literal, groupedexpr, array, object, lambda,
-    ffi, location);
+    oldlambda, ffi, location);
   DONE();
 
 // ref | this | literal | tuple | array | object | lambda | ffi | location
 DEF(nextatom);
   RULE("value", ref, thisliteral, literal, nextgroupedexpr, nextarray, object,
-    lambda, ffi, location);
+    lambda, oldlambda, ffi, location);
   DONE();
 
 // DOT ID
@@ -461,6 +487,13 @@ DEF(tilde);
   TOKEN("method name", TK_ID);
   DONE();
 
+// CHAIN ID
+DEF(chain);
+  INFIX_BUILD();
+  TOKEN(NULL, TK_CHAIN);
+  TOKEN("method name", TK_ID);
+  DONE();
+
 // typeargs
 DEF(qualify);
   INFIX_BUILD();
@@ -478,16 +511,16 @@ DEF(call);
   TERMINATE("call arguments", TK_RPAREN);
   DONE();
 
-// atom {dot | tilde | qualify | call}
+// atom {dot | tilde | chain | qualify | call}
 DEF(postfix);
   RULE("value", atom);
-  SEQ("postfix expression", dot, tilde, qualify, call);
+  SEQ("postfix expression", dot, tilde, chain, qualify, call);
   DONE();
 
-// atom {dot | tilde | qualify | call}
+// atom {dot | tilde | chain | qualify | call}
 DEF(nextpostfix);
   RULE("value", nextatom);
-  SEQ("postfix expression", dot, tilde, qualify, call);
+  SEQ("postfix expression", dot, tilde, chain, qualify, call);
   DONE();
 
 // (VAR | LET | EMBED | $LET) ID [COLON type]
diff --git a/src/libponyc/ast/token.h b/src/libponyc/ast/token.h
index a846a2512e..6d2548d446 100644
--- a/src/libponyc/ast/token.h
+++ b/src/libponyc/ast/token.h
@@ -41,6 +41,7 @@ typedef enum token_id
   TK_DBLARROW,
   TK_DOT,
   TK_TILDE,
+  TK_CHAIN,
   TK_COLON,
   TK_SEMI,
   TK_ASSIGN,
@@ -237,6 +238,8 @@ typedef enum token_id
   TK_NEWAPP,
   TK_BEAPP,
   TK_FUNAPP,
+  TK_BECHAIN,
+  TK_FUNCHAIN,
 
   // Pseudo tokens that never actually exist
   TK_NEWLINE,  // Used by parser macros
diff --git a/src/libponyc/ast/treecheckdef.h b/src/libponyc/ast/treecheckdef.h
index 7f3c26f671..161fa9aa4c 100644
--- a/src/libponyc/ast/treecheckdef.h
+++ b/src/libponyc/ast/treecheckdef.h
@@ -330,14 +330,15 @@ RULE(try_expr,
 
 RULE(lambda,
   HAS_TYPE(type)
-  CHILD(cap, none)
+  CHILD(cap, none) // Receiver cap
   CHILD(id, none)
   CHILD(type_params, none)
   CHILD(params, none)
   CHILD(lambda_captures, none)
   CHILD(type, none) // Return
   CHILD(question, none)
-  CHILD(rawseq),
+  CHILD(rawseq)
+  CHILD(cap, none, question), // Type reference cap (? indicates old syntax)
   TK_LAMBDA);
 
 RULE(lambda_captures, ONE_OR_MORE(lambda_capture), TK_LAMBDACAPTURES);
diff --git a/src/libponyc/codegen/codegen.c b/src/libponyc/codegen/codegen.c
index cf9cb2fde3..1f06994781 100644
--- a/src/libponyc/codegen/codegen.c
+++ b/src/libponyc/codegen/codegen.c
@@ -698,7 +698,7 @@ static void init_runtime(compile_t* c)
   c->personality = LLVMAddFunction(c->module, "pony_personality_v0", type);
 }
 
-static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
+static bool init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
 {
   c->opt = opt;
 
@@ -710,10 +710,6 @@ static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
   if(builtin == NULL)
     builtin = package;
 
-  c->reach = reach_new();
-
-  c->tbaa_mds = tbaa_metadatas_new();
-
   // The name of the first package is the name of the program.
   c->filename = package_filename(package);
 
@@ -728,9 +724,13 @@ static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
   else
     c->linkage = LLVMPrivateLinkage;
 
-  c->context = LLVMContextCreate();
   c->machine = make_machine(opt);
 
+  if(c->machine == NULL)
+    return false;
+
+  c->context = LLVMContextCreate();
+
   // Create a module.
   c->module = LLVMModuleCreateWithNameInContext(c->filename, c->context);
 
@@ -758,6 +758,11 @@ static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
 
   // Empty frame stack.
   c->frame = NULL;
+
+  c->reach = reach_new();
+  c->tbaa_mds = tbaa_metadatas_new();
+
+  return true;
 }
 
 bool codegen_merge_runtime_bitcode(compile_t* c)
@@ -888,7 +893,9 @@ bool codegen(ast_t* program, pass_opt_t* opt)
   compile_t c;
   memset(&c, 0, sizeof(compile_t));
 
-  init_module(&c, program, opt);
+  if(!init_module(&c, program, opt))
+    return false;
+
   init_runtime(&c);
   genprim_reachable_init(&c, program);
 
diff --git a/src/libponyc/codegen/gencall.c b/src/libponyc/codegen/gencall.c
index 70e3d6f819..2aa7798c9b 100644
--- a/src/libponyc/codegen/gencall.c
+++ b/src/libponyc/codegen/gencall.c
@@ -489,6 +489,8 @@ LLVMValueRef gen_call(compile_t* c, ast_t* ast)
     case TK_NEWBEREF:
     case TK_BEREF:
     case TK_FUNREF:
+    case TK_BECHAIN:
+    case TK_FUNCHAIN:
       typeargs = method;
       AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
       break;
@@ -600,6 +602,8 @@ LLVMValueRef gen_call(compile_t* c, ast_t* ast)
 
       case TK_BEREF:
       case TK_FUNREF:
+      case TK_BECHAIN:
+      case TK_FUNCHAIN:
         args[0] = gen_expr(c, receiver);
         break;
 
@@ -700,6 +704,10 @@ LLVMValueRef gen_call(compile_t* c, ast_t* ast)
      (t->underlying == TK_CLASS))
     r = args[0];
 
+  // Chained methods forward their receiver.
+  if((ast_id(postfix) == TK_BECHAIN) || (ast_id(postfix) == TK_FUNCHAIN))
+    r = args[0];
+
   ponyint_pool_free_size(buf_size, args);
   ponyint_pool_free_size(buf_size, params);
   return r;
diff --git a/src/libponyc/codegen/genname.c b/src/libponyc/codegen/genname.c
index 10f58793b2..04098ac0ff 100644
--- a/src/libponyc/codegen/genname.c
+++ b/src/libponyc/codegen/genname.c
@@ -14,24 +14,24 @@ static void type_append(printbuf_t* buf, ast_t* type, bool first)
   {
     case TK_UNIONTYPE:
     {
-      // 3u_Arg1_Arg2_Arg3
-      printbuf(buf, "%du", ast_childcount(type));
+      // u3_Arg1_Arg2_Arg3
+      printbuf(buf, "u%d", ast_childcount(type));
       types_append(buf, type);
       return;
     }
 
     case TK_ISECTTYPE:
     {
-      // 3i_Arg1_Arg2_Arg3
-      printbuf(buf, "%di", ast_childcount(type));
+      // i3_Arg1_Arg2_Arg3
+      printbuf(buf, "i%d", ast_childcount(type));
       types_append(buf, type);
       return;
     }
 
     case TK_TUPLETYPE:
     {
-      // 3t_Arg1_Arg2_Arg3
-      printbuf(buf, "%dt", ast_childcount(type));
+      // t3_Arg1_Arg2_Arg3
+      printbuf(buf, "t%d", ast_childcount(type));
       types_append(buf, type);
       return;
     }
diff --git a/src/libponyc/expr/call.c b/src/libponyc/expr/call.c
index 91c2ca6ae1..0068352e73 100644
--- a/src/libponyc/expr/call.c
+++ b/src/libponyc/expr/call.c
@@ -89,7 +89,7 @@ static bool check_type_params(pass_opt_t* opt, ast_t** astp)
   if(ast_id(typeparams) == TK_NONE)
     return true;
 
-  BUILD(typeargs, typeparams, NODE(TK_TYPEARGS));
+  BUILD(typeargs, ast_parent(lhs), NODE(TK_TYPEARGS));
 
   if(!reify_defaults(typeparams, typeargs, true, opt))
   {
@@ -294,9 +294,23 @@ static bool check_arg_types(pass_opt_t* opt, ast_t* params, ast_t* positional,
 static bool auto_recover_call(ast_t* ast, ast_t* receiver_type,
   ast_t* positional, ast_t* result)
 {
+  switch(ast_id(ast))
+  {
+    case TK_FUNREF:
+    case TK_FUNAPP:
+    case TK_FUNCHAIN:
+      break;
+
+    default:
+      assert(0);
+      break;
+  }
+
   // We can recover the receiver (ie not alias the receiver type) if all
   // arguments are safe and the result is either safe or unused.
-  if(is_result_needed(ast) && !safe_to_autorecover(receiver_type, result))
+  // The result of a chained method is always unused.
+  ast_t* call = ast_parent(ast);
+  if(is_result_needed(call) && !safe_to_autorecover(receiver_type, result))
     return false;
 
   ast_t* arg = ast_child(positional);
@@ -324,7 +338,21 @@ static bool auto_recover_call(ast_t* ast, ast_t* receiver_type,
   return true;
 }
 
-static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast)
+static ast_t* method_receiver_type(ast_t* method)
+{
+  ast_t* receiver = ast_child(method);
+
+  // Dig through function qualification.
+  if((ast_id(receiver) == TK_FUNREF) || (ast_id(receiver) == TK_FUNAPP) ||
+     (ast_id(receiver) == TK_FUNCHAIN))
+    receiver = ast_child(receiver);
+
+  ast_t* r_type = ast_type(receiver);
+
+  return r_type;
+}
+
+static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast, bool* recovered)
 {
   AST_GET_CHILDREN(ast, positional, namedargs, lhs);
 
@@ -335,15 +363,8 @@ static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast)
 
   AST_GET_CHILDREN(type, cap, typeparams, params, result);
 
-  // Check receiver cap.
-  ast_t* receiver = ast_child(lhs);
-
-  // Dig through function qualification.
-  if(ast_id(receiver) == TK_FUNREF || ast_id(receiver) == TK_FUNAPP)
-    receiver = ast_child(receiver);
-
   // Receiver type, alias of receiver type, and target type.
-  ast_t* r_type = ast_type(receiver);
+  ast_t* r_type = method_receiver_type(lhs);
 
   if(is_typecheck_error(r_type))
     return false;
@@ -352,7 +373,7 @@ static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast)
   ast_t* a_type;
 
   // If we can recover the receiver, we don't alias it here.
-  bool can_recover = auto_recover_call(ast, r_type, positional, result);
+  bool can_recover = auto_recover_call(lhs, r_type, positional, result);
   bool cap_recover = false;
 
   switch(ast_id(cap))
@@ -373,9 +394,17 @@ static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast)
   }
 
   if(can_recover && cap_recover)
+  {
     a_type = r_type;
+    if(recovered != NULL)
+      *recovered = true;
+  }
   else
+  {
     a_type = alias(r_type);
+    if(recovered != NULL)
+      *recovered = false;
+  }
 
   errorframe_t info = NULL;
   bool ok = is_subtype(a_type, t_type, &info, opt);
@@ -386,7 +415,7 @@ static bool check_receiver_cap(pass_opt_t* opt, ast_t* ast)
 
     ast_error_frame(&frame, ast,
       "receiver type is not a subtype of target type");
-    ast_error_frame(&frame, receiver,
+    ast_error_frame(&frame, ast_child(lhs),
       "receiver type: %s", ast_print_type(a_type));
     ast_error_frame(&frame, cap,
       "target type: %s", ast_print_type(t_type));
@@ -437,7 +466,7 @@ static bool method_application(pass_opt_t* opt, ast_t* ast, bool partial)
   {
     case TK_FUNREF:
     case TK_FUNAPP:
-      if(!check_receiver_cap(opt, ast))
+      if(!check_receiver_cap(opt, ast, NULL))
         return false;
       break;
 
@@ -523,7 +552,7 @@ static bool partial_application(pass_opt_t* opt, ast_t** astp)
    *
    * Partial call is converted to:
    * ```pony
-   * lambda(b: B = b_default)($0 = recv, a = foo): R => $0.f[T2](a, consume b)
+   * {(b: B = b_default)($0 = recv, a = foo): R => $0.f[T2](a, consume b) }
    * ```
    */
 
@@ -675,7 +704,8 @@ static bool partial_application(pass_opt_t* opt, ast_t** astp)
         NODE(TK_CALL,
           TREE(lambda_call_args)
           NONE  // Named args.
-          TREE(call_receiver)))));
+          TREE(call_receiver)))
+      NONE)); // Lambda reference capability.
 
   // Need to preserve various lambda children.
   ast_setflag(ast_childidx(*astp, 2), AST_FLAG_PRESERVE); // Type params.
@@ -687,6 +717,33 @@ static bool partial_application(pass_opt_t* opt, ast_t** astp)
   return ast_passes_subtree(astp, opt, PASS_EXPR);
 }
 
+static bool method_chain(pass_opt_t* opt, ast_t* ast)
+{
+  if(!method_application(opt, ast, false))
+    return false;
+
+  // We check the receiver cap now instead of in method_application because
+  // we need to know whether the receiver was recovered.
+  ast_t* lhs = ast_childidx(ast, 2);
+  ast_t* r_type = method_receiver_type(lhs);
+  if(ast_id(lhs) == TK_FUNCHAIN)
+  {
+    bool recovered;
+    if(!check_receiver_cap(opt, ast, &recovered))
+      return false;
+
+    ast_t* f_type = ast_type(lhs);
+    token_id f_cap = ast_id(ast_child(f_type));
+
+    ast_t* c_type = chain_type(r_type, f_cap, recovered);
+    ast_settype(ast, c_type);
+  } else {
+    ast_settype(ast, r_type);
+  }
+
+  return true;
+}
+
 bool expr_call(pass_opt_t* opt, ast_t** astp)
 {
   ast_t* ast = *astp;
@@ -716,6 +773,10 @@ bool expr_call(pass_opt_t* opt, ast_t** astp)
     case TK_FUNAPP:
       return partial_application(opt, astp);
 
+    case TK_BECHAIN:
+    case TK_FUNCHAIN:
+      return method_chain(opt, ast);
+
     default: {}
   }
 
diff --git a/src/libponyc/expr/lambda.c b/src/libponyc/expr/lambda.c
index 045e08b5f4..46ccf14895 100644
--- a/src/libponyc/expr/lambda.c
+++ b/src/libponyc/expr/lambda.c
@@ -92,8 +92,8 @@ bool expr_lambda(pass_opt_t* opt, ast_t** astp)
   ast_t* ast = *astp;
   assert(ast != NULL);
 
-  AST_GET_CHILDREN(ast, cap, name, t_params, params, captures, ret_type,
-    raises, body);
+  AST_GET_CHILDREN(ast, receiver_cap, name, t_params, params, captures,
+    ret_type, raises, body, reference_cap);
 
   ast_t* members = ast_from(ast, TK_MEMBERS);
   ast_t* last_member = NULL;
@@ -130,7 +130,7 @@ bool expr_lambda(pass_opt_t* opt, ast_t** astp)
   // Make the apply function
   BUILD(apply, ast,
     NODE(TK_FUN, AST_SCOPE
-      TREE(cap)
+      TREE(receiver_cap)
       ID(fn_name)
       TREE(t_params)
       TREE(params)
@@ -143,7 +143,7 @@ bool expr_lambda(pass_opt_t* opt, ast_t** astp)
   ast_list_append(members, &last_member, apply);
 
   printbuf_t* buf = printbuf_new();
-  printbuf(buf, "lambda(");
+  printbuf(buf, "{(");
   bool first = true;
 
   for(ast_t* p = ast_child(params); p != NULL; p = ast_sibling(p))
@@ -164,12 +164,12 @@ bool expr_lambda(pass_opt_t* opt, ast_t** astp)
   if(ast_id(raises) != TK_NONE)
     printbuf(buf, " ?");
 
-  printbuf(buf, " end");
+  printbuf(buf, "}");
 
   // Replace lambda with object literal
   REPLACE(astp,
     NODE(TK_OBJECT, DATA(stringtab(buf->m))
-      NONE
+      TREE(reference_cap)
       NONE  // Provides list
       TREE(members)));
 
diff --git a/src/libponyc/expr/literal.c b/src/libponyc/expr/literal.c
index b1298bf8c7..f36d1c2a66 100644
--- a/src/libponyc/expr/literal.c
+++ b/src/libponyc/expr/literal.c
@@ -844,7 +844,8 @@ static bool unify(ast_t* ast, pass_opt_t* opt, bool report_errors)
 bool literal_member_access(ast_t* ast, pass_opt_t* opt)
 {
   assert(ast != NULL);
-  assert(ast_id(ast) == TK_DOT || ast_id(ast) == TK_TILDE);
+  assert(ast_id(ast) == TK_DOT || ast_id(ast) == TK_TILDE ||
+    ast_id(ast) == TK_CHAIN);
 
   AST_GET_CHILDREN(ast, receiver, name_node);
 
diff --git a/src/libponyc/expr/postfix.c b/src/libponyc/expr/postfix.c
index 63467d5a86..7b701fe72e 100644
--- a/src/libponyc/expr/postfix.c
+++ b/src/libponyc/expr/postfix.c
@@ -102,6 +102,22 @@ static bool constructor_type(pass_opt_t* opt, ast_t* ast, token_id cap,
       return constructor_type(opt, ast, cap, right, resultp);
     }
 
+    case TK_UNIONTYPE:
+    {
+      ast_error(opt->check.errors, ast,
+        "can't call a constructor on a type union: %s",
+        ast_print_type(type));
+      return false;
+    }
+
+    case TK_ISECTTYPE:
+    {
+      ast_error(opt->check.errors, ast,
+        "can't call a constructor on a type intersection: %s",
+        ast_print_type(type));
+      return false;
+    }
+
     default: {}
   }
 
@@ -496,6 +512,8 @@ bool expr_qualify(pass_opt_t* opt, ast_t** astp)
     case TK_NEWAPP:
     case TK_BEAPP:
     case TK_FUNAPP:
+    case TK_BECHAIN:
+    case TK_FUNCHAIN:
     {
       // Qualify the function.
       assert(ast_id(type) == TK_FUNTYPE);
@@ -531,7 +549,7 @@ bool expr_qualify(pass_opt_t* opt, ast_t** astp)
   return expr_qualify(opt, astp);
 }
 
-static bool dot_or_tilde(pass_opt_t* opt, ast_t** astp)
+static bool entity_access(pass_opt_t* opt, ast_t** astp)
 {
   ast_t* ast = *astp;
 
@@ -572,12 +590,12 @@ static bool dot_or_tilde(pass_opt_t* opt, ast_t** astp)
 
 bool expr_dot(pass_opt_t* opt, ast_t** astp)
 {
-  return dot_or_tilde(opt, astp);
+  return entity_access(opt, astp);
 }
 
 bool expr_tilde(pass_opt_t* opt, ast_t** astp)
 {
-  if(!dot_or_tilde(opt, astp))
+  if(!entity_access(opt, astp))
     return false;
 
   ast_t* ast = *astp;
@@ -623,3 +641,45 @@ bool expr_tilde(pass_opt_t* opt, ast_t** astp)
   assert(0);
   return false;
 }
+
+bool expr_chain(pass_opt_t* opt, ast_t** astp)
+{
+  if(!entity_access(opt, astp))
+    return false;
+
+  ast_t* ast = *astp;
+
+  switch(ast_id(ast))
+  {
+    case TK_BEREF:
+      ast_setid(ast, TK_BECHAIN);
+      return true;
+
+    case TK_FUNREF:
+      ast_setid(ast, TK_FUNCHAIN);
+      return true;
+
+    case TK_NEWREF:
+    case TK_NEWBEREF:
+      ast_error(opt->check.errors, ast,
+        "can't do method chaining on a constructor");
+      return false;
+
+    case TK_TYPEREF:
+      ast_error(opt->check.errors, ast,
+        "can't do method chaining on a package");
+      return false;
+
+    case TK_FVARREF:
+    case TK_FLETREF:
+    case TK_EMBEDREF:
+      ast_error(opt->check.errors, ast,
+        "can't do method chaining on a field");
+      return false;
+
+    default: {}
+  }
+
+  assert(0);
+  return false;
+}
diff --git a/src/libponyc/expr/postfix.h b/src/libponyc/expr/postfix.h
index c66ca0dceb..9cd5e75b32 100644
--- a/src/libponyc/expr/postfix.h
+++ b/src/libponyc/expr/postfix.h
@@ -10,6 +10,7 @@ PONY_EXTERN_C_BEGIN
 bool expr_qualify(pass_opt_t* opt, ast_t** astp);
 bool expr_dot(pass_opt_t* opt, ast_t** astp);
 bool expr_tilde(pass_opt_t* opt, ast_t** astp);
+bool expr_chain(pass_opt_t* opt, ast_t** astp);
 
 PONY_EXTERN_C_END
 
diff --git a/src/libponyc/expr/reference.c b/src/libponyc/expr/reference.c
index 09ef9dd15e..37b9421d6d 100644
--- a/src/libponyc/expr/reference.c
+++ b/src/libponyc/expr/reference.c
@@ -675,9 +675,6 @@ bool expr_reference(pass_opt_t* opt, ast_t** astp)
 
       ast_t* type = ast_type(def);
 
-      if(is_typecheck_error(type))
-        return false;
-
       if(type != NULL && ast_id(type) == TK_INFERTYPE)
       {
         ast_error(opt->check.errors, ast, "cannot infer type of %s\n",
@@ -687,6 +684,9 @@ bool expr_reference(pass_opt_t* opt, ast_t** astp)
         return false;
       }
 
+      if(is_typecheck_error(type))
+        return false;
+
       if(!valid_reference(opt, ast, type, status))
         return false;
 
diff --git a/src/libponyc/pass/expr.c b/src/libponyc/pass/expr.c
index cdc2370054..1203d9eb95 100644
--- a/src/libponyc/pass/expr.c
+++ b/src/libponyc/pass/expr.c
@@ -93,6 +93,11 @@ bool is_result_needed(ast_t* ast)
       // Result of a behaviour isn't needed.
       return false;
 
+    case TK_BECHAIN:
+    case TK_FUNCHAIN:
+      // Result of a chained method isn't needed.
+      return false;
+
     default: {}
   }
 
@@ -258,6 +263,7 @@ ast_result_t pass_expr(ast_t** astp, pass_opt_t* options)
     case TK_RECOVER:    r = expr_recover(options, ast); break;
     case TK_DOT:        r = expr_dot(options, astp); break;
     case TK_TILDE:      r = expr_tilde(options, astp); break;
+    case TK_CHAIN:      r = expr_chain(options, astp); break;
     case TK_QUALIFY:    r = expr_qualify(options, astp); break;
     case TK_CALL:       r = expr_call(options, astp); break;
     case TK_IFDEF:
diff --git a/src/libponyc/pass/syntax.c b/src/libponyc/pass/syntax.c
index 9783ac51f4..3826020fd9 100644
--- a/src/libponyc/pass/syntax.c
+++ b/src/libponyc/pass/syntax.c
@@ -935,9 +935,9 @@ static ast_result_t syntax_compile_error(pass_opt_t* opt, ast_t* ast)
 static ast_result_t syntax_lambda(pass_opt_t* opt, ast_t* ast)
 {
   assert(ast_id(ast) == TK_LAMBDA);
-  AST_GET_CHILDREN(ast, cap, name, typeparams, params, captures, type,
-    can_error, body);
-  switch(ast_id(type))
+  AST_GET_CHILDREN(ast, receiver_cap, name, t_params, params, captures,
+    ret_type, raises, body, reference_cap);
+  switch(ast_id(ret_type))
   {
     case TK_ISO:
     case TK_TRN:
@@ -946,9 +946,9 @@ static ast_result_t syntax_lambda(pass_opt_t* opt, ast_t* ast)
     case TK_BOX:
     case TK_TAG:
     {
-      ast_error(opt->check.errors, type, "lambda return type: %s",
-        ast_print_type(type));
-      ast_error_continue(opt->check.errors, type, "lambda return type "
+      ast_error(opt->check.errors, ret_type, "lambda return type: %s",
+        ast_print_type(ret_type));
+      ast_error_continue(opt->check.errors, ret_type, "lambda return type "
         "cannot be capability");
       return AST_ERROR;
     }
@@ -967,6 +967,13 @@ static ast_result_t syntax_lambda(pass_opt_t* opt, ast_t* ast)
     capture = ast_sibling(capture);
   }
 
+  if(ast_id(reference_cap) == TK_QUESTION)
+  {
+    ast_error(opt->check.errors, ast,
+      "lambda ... end is no longer supported syntax; use {...} for lambdas");
+    return AST_ERROR;
+  }
+
   return AST_OK;
 }
 
diff --git a/src/libponyc/type/alias.c b/src/libponyc/type/alias.c
index 4585c504af..26d04f4994 100644
--- a/src/libponyc/type/alias.c
+++ b/src/libponyc/type/alias.c
@@ -1,4 +1,5 @@
 #include "alias.h"
+#include "assemble.h"
 #include "viewpoint.h"
 #include "cap.h"
 #include "../ast/token.h"
@@ -418,6 +419,126 @@ ast_t* recover_type(ast_t* type, token_id cap)
   return NULL;
 }
 
+ast_t* chain_type(ast_t* type, token_id fun_cap, bool recovered_call)
+{
+  switch(ast_id(type))
+  {
+    case TK_UNIONTYPE:
+    case TK_ISECTTYPE:
+    case TK_TUPLETYPE:
+    {
+      ast_t* c_type = ast_from(type, ast_id(type));
+      ast_t* child = ast_child(type);
+
+      while(child != NULL)
+      {
+        ast_append(c_type, chain_type(child, fun_cap, recovered_call));
+        child = ast_sibling(child);
+      }
+
+      return c_type;
+    }
+
+    case TK_NOMINAL:
+    case TK_TYPEPARAMREF:
+    {
+      ast_t* cap = cap_fetch(type);
+      ast_t* eph = ast_sibling(cap);
+
+      switch(ast_id(cap))
+      {
+        case TK_REF:
+        case TK_VAL:
+        case TK_BOX:
+        case TK_TAG:
+        case TK_CAP_READ:
+        case TK_CAP_SHARE:
+        case TK_CAP_ALIAS:
+          // If the receiver type aliases as itself, it stays the same after
+          // chaining.
+          return type;
+
+        default: {}
+      }
+
+      if(ast_id(eph) == TK_NONE)
+      {
+        assert(recovered_call || (fun_cap == TK_TAG));
+        // If the receiver isn't ephemeral, we recovered the call and the type
+        // stays the same.
+        return ast_dup(type);
+      }
+
+      assert(ast_id(eph) == TK_EPHEMERAL);
+
+      // If the call was auto-recovered, no alias can exist outside of the
+      // object's isolation boundary.
+      if(recovered_call)
+        return ast_dup(type);
+
+      switch(ast_id(cap))
+      {
+        case TK_ISO:
+        case TK_CAP_SEND:
+          switch(fun_cap)
+          {
+            case TK_TAG:
+              return ast_dup(type);
+
+            case TK_ISO:
+              return alias(alias(type));
+
+            default: {}
+          }
+          break;
+
+        case TK_TRN:
+          switch(fun_cap)
+          {
+            case TK_TAG:
+            case TK_BOX:
+              return ast_dup(type);
+
+            case TK_TRN:
+              return alias(alias(type));
+
+            default: {}
+          }
+          break;
+
+        default:
+          assert(false);
+          return NULL;
+      }
+
+      return set_cap_and_ephemeral(type, fun_cap, TK_NONE);
+    }
+
+    case TK_ARROW:
+    {
+      // Chain just the right side. the left side is either 'this' or a type
+      // parameter, and stays the same.
+      AST_GET_CHILDREN(type, left, right);
+      ast_t* c_right = chain_type(right, fun_cap, recovered_call);
+
+      ast_t* c_type = ast_from(type, TK_ARROW);
+      ast_add(c_type, c_right);
+      ast_add(c_type, left);
+      return c_type;
+    }
+
+    case TK_FUNTYPE:
+    case TK_INFERTYPE:
+    case TK_ERRORTYPE:
+      return type;
+
+    default: {}
+  }
+
+  assert(0);
+  return NULL;
+}
+
 bool sendable(ast_t* type)
 {
   switch(ast_id(type))
diff --git a/src/libponyc/type/alias.h b/src/libponyc/type/alias.h
index 47d9d6ae11..06a084397c 100644
--- a/src/libponyc/type/alias.h
+++ b/src/libponyc/type/alias.h
@@ -17,6 +17,8 @@ ast_t* consume_type(ast_t* type, token_id cap);
 
 ast_t* recover_type(ast_t* type, token_id cap);
 
+ast_t* chain_type(ast_t* type, token_id fun_cap, bool recovered_call);
+
 bool sendable(ast_t* type);
 
 bool immutable_or_opaque(ast_t* type);
diff --git a/src/libponyrt/gc/serialise.c b/src/libponyrt/gc/serialise.c
index d8527770b9..6efef596f4 100644
--- a/src/libponyrt/gc/serialise.c
+++ b/src/libponyrt/gc/serialise.c
@@ -164,7 +164,7 @@ void pony_serialise(pony_ctx_t* ctx, void* p, void* out)
   ponyint_array_t* r = (ponyint_array_t*)out;
   r->size = ctx->serialise_size;
   r->alloc = r->size;
-  r->ptr = (char*)ponyint_pool_alloc_size(r->size);
+  r->ptr = (char*)pony_alloc(ctx, r->size);
 
   size_t i = HASHMAP_BEGIN;
   serialise_t* s;
diff --git a/src/libponyrt/sched/mpmcq.c b/src/libponyrt/sched/mpmcq.c
index b57996589b..3e6de422ac 100644
--- a/src/libponyrt/sched/mpmcq.c
+++ b/src/libponyrt/sched/mpmcq.c
@@ -103,3 +103,16 @@ void* ponyint_mpmcq_pop(mpmcq_t* q)
   POOL_FREE(mpmcq_node_t, tail);
   return data;
 }
+
+void* ponyint_mpmcq_pop_bailout_immediate(mpmcq_t* q)
+{
+  mpmcq_node_t* head = atomic_load_explicit(&q->head, memory_order_relaxed);
+  mpmcq_node_t* tail = atomic_load_explicit(&q->tail, memory_order_relaxed);
+
+  // If we believe the queue is empty, bailout immediately without taking a
+  // ticket to avoid unnecessary contention.
+  if(head == tail)
+    return NULL;
+
+  return ponyint_mpmcq_pop(q);
+}
diff --git a/src/libponyrt/sched/mpmcq.h b/src/libponyrt/sched/mpmcq.h
index e969a96a77..dcfc821f7c 100644
--- a/src/libponyrt/sched/mpmcq.h
+++ b/src/libponyrt/sched/mpmcq.h
@@ -29,6 +29,8 @@ void ponyint_mpmcq_push_single(mpmcq_t* q, void* data);
 
 void* ponyint_mpmcq_pop(mpmcq_t* q);
 
+void* ponyint_mpmcq_pop_bailout_immediate(mpmcq_t* q);
+
 PONY_EXTERN_C_END
 
 #endif
diff --git a/src/libponyrt/sched/scheduler.c b/src/libponyrt/sched/scheduler.c
index ee79629f6b..2bfa579b86 100644
--- a/src/libponyrt/sched/scheduler.c
+++ b/src/libponyrt/sched/scheduler.c
@@ -53,7 +53,10 @@ static void push(scheduler_t* sched, pony_actor_t* actor)
  */
 static pony_actor_t* pop_global(scheduler_t* sched)
 {
-  pony_actor_t* actor = (pony_actor_t*)ponyint_mpmcq_pop(&inject);
+  // The global queue is empty most of the time. We use pop_bailout_immediate
+  // to avoid unnecessary synchronisation in that common case.
+  pony_actor_t* actor =
+    (pony_actor_t*)ponyint_mpmcq_pop_bailout_immediate(&inject);
 
   if(actor != NULL)
     return actor;
diff --git a/src/ponyc/main.c b/src/ponyc/main.c
index b9e90c9059..ac99be3e9d 100644
--- a/src/ponyc/main.c
+++ b/src/ponyc/main.c
@@ -249,57 +249,6 @@ static bool compile_package(const char* path, pass_opt_t* opt,
   return ok;
 }
 
-static char* compiler_version()
-{
-#ifdef PLATFORM_IS_WINDOWS
-  const int size = 128;
-  static char buff[size];
-  buff[0] = 0;
-
-# if defined(_MSC_FULL_VER) && defined(NTDDI_VERSION)
-  uint64_t vcver = _MSC_FULL_VER;
-  int vcmaj = (int)(vcver / 10000000);
-  int vcmin = (int)((vcver % 10000000) / 1000000);
-  int vcbld = (int)(vcver % 1000000);
-  int vcday = _MSC_BUILD;
-
-  uint64_t osver = NTDDI_VERSION;
-  int osmaj = (int)(osver / 10000000);
-  int osmin = (int)((osver % 10000000) / 100000);
-  int osbld = (int)(osver % 100000);
-
-  snprintf(buff, size,
-    "VC++ %02d.%02d.%d.%d Windows %02d.%02d.%d",
-    vcmaj, vcmin, vcbld, vcday,
-    osmaj, osmin, osbld);
-  return buff;
-# else
-  return "?";
-# endif
-#else
-  char* cc = PONY_COMPILER;
-  char* args = " --version";
-  size_t idx = ponyint_pool_index(strlen(cc) + strlen(args));
-  char* cmd = ponyint_pool_alloc(idx);
-  strcat(cmd, cc);
-  strcat(cmd, args);
-
-  FILE* fp = popen(cmd, "r");
-  ponyint_pool_free(idx, cmd);
-  if (fp == NULL)
-    return cc;
-
-  char buff[60];
-  char* info = fgets(buff, sizeof(buff), fp);
-  pclose(fp);
-  if (info == NULL)
-    return cc;
-
-  strtok(info, "\n");
-  return info;
-#endif
-}
-
 int main(int argc, char* argv[])
 {
   stringtab_init();
@@ -326,8 +275,8 @@ int main(int argc, char* argv[])
     switch(id)
     {
       case OPT_VERSION:
-        printf("%s [%s] (llvm %s) (%s)\n", PONY_VERSION, PONY_BUILD_CONFIG,
-          LLVM_VERSION, compiler_version());
+        printf("%s [%s]\ncompiled with: llvm %s -- %s\n", PONY_VERSION, PONY_BUILD_CONFIG,
+          LLVM_VERSION, BUILD_COMPILER);
         return 0;
 
       case OPT_DEBUG: opt.release = false; break;
diff --git a/test/libponyc/badpony.cc b/test/libponyc/badpony.cc
index 4b15e57f54..baa38b90c3 100644
--- a/test/libponyc/badpony.cc
+++ b/test/libponyc/badpony.cc
@@ -126,7 +126,7 @@ TEST_F(BadPonyTest, InvalidLambdaReturnType)
   const char* src =
     "actor Main\n"
     "  new create(env: Env) =>\n"
-    "    lambda (): tag => this end\n";
+    "    {(): tag => this }\n";
 
   TEST_ERRORS_1(src, "lambda return type: tag");
 }
@@ -161,7 +161,7 @@ TEST_F(BadPonyTest, LambdaCaptureVariableBeforeDeclarationWithTypeInferenceExpre
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda()(x) => None end\n"
+    "    {()(x) => None }\n"
     "    let x = 0";
 
    TEST_ERRORS_1(src, "declaration of 'x' appears after use");
@@ -259,7 +259,9 @@ TEST_F(BadPonyTest, WithBlockTypeInference)
     "  new create(env: Env) =>\n"
     "    with x = 1 do None end";
 
-  TEST_ERRORS_1(src, "could not infer literal type, no valid types found");
+  TEST_ERRORS_3(src, "could not infer literal type, no valid types found",
+                     "cannot infer type of $1$0",
+                     "cannot infer type of x");
 }
 
 TEST_F(BadPonyTest, EmbedNestedTuple)
@@ -278,3 +280,31 @@ TEST_F(BadPonyTest, EmbedNestedTuple)
 
   TEST_ERRORS_1(src, "an embedded field must be assigned using a constructor");
 }
+
+TEST_F(BadPonyTest, CircularTypeInfer)
+{
+  // From issue #1334
+  const char* src =
+    "actor Main\n"
+    "  new create(env: Env) =>\n"
+    "    let x = x.create()\n"
+    "    let y = y.create()";
+
+  TEST_ERRORS_2(src, "cannot infer type of x",
+                     "cannot infer type of y");
+}
+
+TEST_F(BadPonyTest, CallConstructorOnTypeIntersection)
+{
+  // From issue #1398
+  const char* src =
+    "interface Foo\n"
+
+    "type Isect is (None & Foo)\n"
+
+    "actor Main\n"
+    "  new create(env: Env) =>\n"
+    "    Isect.create()";
+
+  TEST_ERRORS_1(src, "can't call a constructor on a type intersection");
+}
diff --git a/test/libponyc/chain.cc b/test/libponyc/chain.cc
new file mode 100644
index 0000000000..2befa9a3bb
--- /dev/null
+++ b/test/libponyc/chain.cc
@@ -0,0 +1,124 @@
+#include <gtest/gtest.h>
+#include <platform.h>
+
+#include "util.h"
+
+
+#define TEST_COMPILE(src) DO(test_compile(src, "expr"))
+
+#define TEST_ERRORS_1(src, err1) \
+  { const char* errs[] = {err1, NULL}; \
+    DO(test_expected_errors(src, "ir", errs)); }
+
+#define TEST_ERRORS_2(src, err1, err2) \
+  { const char* errs[] = {err1, err2, NULL}; \
+    DO(test_expected_errors(src, "ir", errs)); }
+
+
+class ChainTest : public PassTest
+{};
+
+
+TEST_F(ChainTest, Chain_AliasRefcap)
+{
+  const char* src =
+    "class C\n"
+    "  fun tag x() => None\n"
+
+    "  fun apply() =>\n"
+    "    let r: C ref = C\n"
+    "    let r2: C ref = r.>x()\n"
+    "    let v: C val = C\n"
+    "    let v2: C val = v.>x()\n"
+    "    let b: C box = C\n"
+    "    let b2: C box = b.>x()\n"
+    "    let t: C tag = C\n"
+    "    let t2: C tag = t.>x()";
+
+  TEST_COMPILE(src);
+}
+
+TEST_F(ChainTest, Chain_UniqueRefcap)
+{
+  const char* src =
+    "class C\n"
+    "  fun ref x() => None\n"
+
+    "  fun apply() =>\n"
+    "    let i: C iso = C\n"
+    "    let i2: C iso = i.>x()\n"
+    "    let t: C trn = C\n"
+    "    let t2: C trn = t.>x()";
+
+  TEST_ERRORS_2(src,
+    "right side must be a subtype of left side",
+    "right side must be a subtype of left side");
+}
+
+TEST_F(ChainTest, Chain_UniqueEphRecoverCall)
+{
+  const char* src =
+    "class C\n"
+    "  new iso create() => None\n"
+    "  new trn trn_create() => None\n"
+    "  fun ref x() => None\n"
+
+    "  fun apply() =>\n"
+    "    let i: C iso = C.>x()\n"
+    "    let t: C trn = C.trn_create().>x()";
+
+  TEST_COMPILE(src);
+}
+
+TEST_F(ChainTest, Chain_UniqueEphSubtypeMethodCap)
+{
+  const char* src =
+    "class C\n"
+    "  new iso create() => None\n"
+    "  new trn trn_create() => None\n"
+    "  fun tag x(c: C ref) => None\n"
+    "  fun box y(c: C ref) => None\n"
+
+    "  fun apply() =>\n"
+    "    let r: C ref = C\n"
+    "    let i: C iso = C.>x(r)\n"
+    "    let t: C trn = C.trn_create().>y(r)";
+
+  TEST_COMPILE(src);
+}
+
+TEST_F(ChainTest, Chain_UniqueEphSameMethodCap)
+{
+  const char* src =
+    "class C\n"
+    "  new iso create() => None\n"
+    "  new trn trn_create() => None\n"
+    "  fun iso x() => None\n"
+    "  fun trn y() => None\n"
+
+    "  fun apply() =>\n"
+    "    let i: C iso = C.>x()\n"
+    "    let t: C trn = C.trn_create().>y()";
+
+  TEST_ERRORS_2(src,
+    "right side must be a subtype of left side",
+    "right side must be a subtype of left side");
+}
+
+TEST_F(ChainTest, Chain_UniqueEphNoRecoverCall)
+{
+  const char* src =
+    "class C\n"
+    "  new iso create() => None\n"
+    "  new trn trn_create() => None\n"
+    "  fun ref x(c: C ref) => None\n"
+
+    "  fun apply() =>\n"
+    "    let r: C ref = C\n"
+    "    let i: C iso = C.>x(r)\n"
+    "    let t: C trn = C.trn_create().>x(r)";
+
+  TEST_ERRORS_2(src,
+    "right side must be a subtype of left side",
+    "right side must be a subtype of left side");
+}
diff --git a/test/libponyc/parse_expr.cc b/test/libponyc/parse_expr.cc
index 657a217154..36f019d250 100644
--- a/test/libponyc/parse_expr.cc
+++ b/test/libponyc/parse_expr.cc
@@ -7,6 +7,10 @@
 #define TEST_ERROR(src) DO(test_error(src, "syntax"))
 #define TEST_COMPILE(src) DO(test_compile(src, "syntax"))
 
+#define TEST_ERRORS_1(src, err1) \
+  { const char* errs[] = {err1, NULL}; \
+    DO(test_expected_errors(src, "syntax", errs)); }
+
 
 class ParseExprTest : public PassTest
 {};
@@ -90,7 +94,7 @@ TEST_F(ParseExprTest, Lambda)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda() => None end";
+    "    {() => None }";
 
   TEST_COMPILE(src);
 }
@@ -101,7 +105,7 @@ TEST_F(ParseExprTest, LambdaCap)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda iso() => None end";
+    "    {iso() => None }";
 
   TEST_COMPILE(src);
 }
@@ -112,7 +116,7 @@ TEST_F(ParseExprTest, LambdaCaptureVariable)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   TEST_COMPILE(src);
 }
@@ -123,7 +127,7 @@ TEST_F(ParseExprTest, LambdaCaptureExpression)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda()(x = y) => None end";
+    "    {()(x = y) => None }";
 
   TEST_COMPILE(src);
 }
@@ -134,7 +138,7 @@ TEST_F(ParseExprTest, LambdaCaptureExpressionAndType)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda()(x: T = y) => None end";
+    "    {()(x: T = y) => None }";
 
   TEST_COMPILE(src);
 }
@@ -145,12 +149,24 @@ TEST_F(ParseExprTest, LambdaCaptureTypeWithoutExpressionFail)
   const char* src =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda()(x: T) => None end";
+    "    {()(x: T) => None }";
 
   TEST_ERROR(src);
 }
 
 
+TEST_F(ParseExprTest, LambdaOldSyntax)
+{
+  const char* src =
+    "actor Main\n"
+    "  new create(env: Env) =>\n"
+    "    lambda() => None end";
+
+  TEST_ERRORS_1(src,
+    "lambda ... end is no longer supported syntax; use {...} for lambdas");
+}
+
+
 // Compile error
 
 TEST_F(ParseExprTest, CompileErrorAllowedAsIfdefClause)
diff --git a/test/libponyc/sugar.cc b/test/libponyc/sugar.cc
index 98ecb88818..d7de9815de 100644
--- a/test/libponyc/sugar.cc
+++ b/test/libponyc/sugar.cc
@@ -2709,7 +2709,7 @@ TEST_F(SugarTest, AsOperatorWithLambdaType)
   const char* short_form =
     "class Foo\n"
       "new create() =>\n"
-        "let x = lambda():U32 => 0 end\n"
+        "let x = {():U32 => 0 }\n"
         "try x as {():U32} val end";
 
   TEST_COMPILE(short_form);
diff --git a/test/libponyc/sugar_expr.cc b/test/libponyc/sugar_expr.cc
index 19a8b10fe6..a8b9155c8c 100644
--- a/test/libponyc/sugar_expr.cc
+++ b/test/libponyc/sugar_expr.cc
@@ -33,7 +33,7 @@ TEST_F(SugarExprTest, PartialMinimal)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x) => $1.f() end";
+    "    {box()($1 = x) => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -55,7 +55,7 @@ TEST_F(SugarExprTest, PartialReceiverCapability)
 
     "class Foo\n"
     "  fun f(x: T ref) =>\n"
-    "    lambda ref()($1 = x) => $1.f() end";
+    "    {ref()($1 = x) => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -117,10 +117,10 @@ TEST_F(SugarExprTest, PartialSomeArgs)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box(b: U32, d: U32)\n"
+    "    {box(b: U32, d: U32)\n"
     "      ($1 = x, a: U32 = (3), c: U32 = (4)) =>\n"
     "      $1.f(a, consume b, c, consume d)\n"
-    "    end";
+    "    }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -142,10 +142,10 @@ TEST_F(SugarExprTest, PartialAllArgs)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x, a: U32 = (1), b: U32 = (2), c: U32 = (3),\n"
+    "    {box()($1 = x, a: U32 = (1), b: U32 = (2), c: U32 = (3),\n"
     "      d: U32 = (4)) =>\n"
     "      $1.f(a, b, c, d)\n"
-    "    end";
+    "    }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -167,10 +167,10 @@ TEST_F(SugarExprTest, PartialDefaultArgs)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box(b: U32 = 2, d: U32 = 4)\n"
+    "    {box(b: U32 = 2, d: U32 = 4)\n"
     "      ($1 = x, a: U32 = (5), c: U32 = (6)) =>\n"
     "      $1.f(a, consume b, c, consume d)\n"
-    "    end";
+    "    }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -192,7 +192,7 @@ TEST_F(SugarExprTest, PartialResult)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x): U32 => $1.f() end";
+    "    {box()($1 = x): U32 => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -214,7 +214,7 @@ TEST_F(SugarExprTest, PartialBehaviour)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x): T tag => $1.f() end";
+    "    {box()($1 = x): T tag => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -236,7 +236,7 @@ TEST_F(SugarExprTest, PartialRaisesError)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x): U32 ? => $1.f() end";
+    "    {box()($1 = x): U32 ? => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -258,7 +258,7 @@ TEST_F(SugarExprTest, PartialParameterTypeParameters)
 
     "class Foo[A: T #read]\n"
     "  fun f(t: T box, a: A) =>\n"
-    "    lambda box()($1 = t, a: A = (a)) => $1.f(a) end";
+    "    {box()($1 = t, a: A = (a)) => $1.f(a) }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -280,7 +280,7 @@ TEST_F(SugarExprTest, PartialReceiverTypeParameters)
 
     "class Foo[A: T #read]\n"
     "  fun f(x: A) =>\n"
-    "    lambda box()($1 = x) => $1.f() end";
+    "    {box()($1 = x) => $1.f() }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -302,7 +302,7 @@ TEST_F(SugarExprTest, PartialFunctionTypeParameter)
 
     "class Foo\n"
     "  fun f(x: T) =>\n"
-    "    lambda box()($1 = x, a: U32 = (3)) => $1.f[U32](a) end";
+    "    {box()($1 = x, a: U32 = (3)) => $1.f[U32](a) }";
 
   TEST_EQUIV(short_form, full_form);
 }
@@ -315,7 +315,7 @@ TEST_F(SugarExprTest, LambdaMinimal)
   const char* short_form =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda() => None end";
+    "    {() => None }";
 
   const char* full_form =
     "class Foo\n"
@@ -339,7 +339,7 @@ TEST_F(SugarExprTest, LambdaFull)
 
     "class Foo\n"
     "  fun f(c: C val, d: D2 val) =>\n"
-    "    lambda iso (a: A, b: B)(c, _c = c, _d: D val = d): A => a end";
+    "    {ref(a: A, b: B)(c, _c = c, _d: D val = d): A => a } iso";
 
   const char* full_form =
     "trait A\n"
@@ -350,11 +350,11 @@ TEST_F(SugarExprTest, LambdaFull)
 
     "class Foo\n"
     "  fun f(c: C val, d: D2 val) =>\n"
-    "    object ref\n"
+    "    object iso\n"
     "      var c: C val = c\n"
     "      var _c: C val = c\n"
     "      var _d: D val = d\n"
-    "      fun iso apply(a: A, b: B): A => a\n"
+    "      fun ref apply(a: A, b: B): A => a\n"
     "    end";
 
   TEST_EQUIV(short_form, full_form);
@@ -366,7 +366,7 @@ TEST_F(SugarExprTest, LambdaThrow)
   const char* short_form =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda() ? => error end";
+    "    {() ? => error }";
 
   const char* full_form =
     "class Foo\n"
@@ -386,7 +386,7 @@ TEST_F(SugarExprTest, LambdaWithTypeArgs)
 
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda[A: T]() => None end";
+    "    {[A: T]() => None }";
 
   const char* full_form =
     "trait T\n"
@@ -409,7 +409,7 @@ TEST_F(SugarExprTest, LambdaCaptureLocalLet)
     "class Foo\n"
     "  fun f() =>\n"
     "    let x: U32 = 4\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   const char* full_form =
     "trait T\n"
@@ -434,7 +434,7 @@ TEST_F(SugarExprTest, LambdaCaptureLocalVar)
     "class Foo\n"
     "  fun f() =>\n"
     "    var x: U32 = 4\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   const char* full_form =
     "trait T\n"
@@ -458,7 +458,7 @@ TEST_F(SugarExprTest, LambdaCaptureParameter)
 
     "class Foo\n"
     "  fun f(x: U32) =>\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   const char* full_form =
     "trait T\n"
@@ -482,7 +482,7 @@ TEST_F(SugarExprTest, LambdaCaptureFieldLet)
     "class Foo\n"
     "  let x: U32 = 4\n"
     "  fun f() =>\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   const char* full_form =
     "trait T\n"
@@ -507,7 +507,7 @@ TEST_F(SugarExprTest, LambdaCaptureFieldVar)
     "class Foo\n"
     "  var x: U32 = 4\n"
     "  fun f() =>\n"
-    "    lambda()(x) => None end";
+    "    {()(x) => None }";
 
   const char* full_form =
     "trait T\n"
@@ -529,7 +529,7 @@ TEST_F(SugarExprTest, LambdaNamed)
   const char* short_form =
     "class Foo\n"
     "  fun f() =>\n"
-    "    lambda bar() => None end";
+    "    {bar() => None }";
 
   const char* full_form =
     "class Foo\n"