diff --git a/xo-reader/include/xo/reader/lambda_xs.hpp b/xo-reader/include/xo/reader/lambda_xs.hpp
index ff0da77f..3f49b973 100644
--- a/xo-reader/include/xo/reader/lambda_xs.hpp
+++ b/xo-reader/include/xo/reader/lambda_xs.hpp
@@ -56,6 +56,8 @@ namespace xo {
 
             static void start(parserstatemachine * p_psm);
 
+            virtual const char * get_expect_str() const override;
+
             virtual void on_lambda_token(const token_type & tk,
                                          parserstatemachine * p_psm) override;
             virtual void on_formal_arglist(const std::vector<rp<Variable>> & argl,
diff --git a/xo-reader/src/reader/exprstate.cpp b/xo-reader/src/reader/exprstate.cpp
index ca8ce179..3d447311 100644
--- a/xo-reader/src/reader/exprstate.cpp
+++ b/xo-reader/src/reader/exprstate.cpp
@@ -68,14 +68,20 @@ namespace xo {
 
             log && log(xtag("exstype", p_psm->top_exprstate().exs_type()));
 
-            this->illegal_input_error("exprstate::on_def_token", tk);
+            constexpr const char * c_self_name = "exprstate::on_def_token";
+            const char * exp = get_expect_str();
+
+            this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
         }
 
         void
         exprstate::on_lambda_token(const token_type & tk,
-                                   parserstatemachine * /*p_psm*/)
+                                   parserstatemachine * p_psm)
         {
-            this->illegal_input_error("exprstate::on_lambda_token", tk);
+            constexpr const char * c_self_name = "exprstate::on_lambda_token";
+            const char * exp = this->get_expect_str();
+
+            this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
         }
 
         void
@@ -106,11 +112,9 @@ namespace xo {
                             p_psm->top_exprstate().exs_type()));
 
             constexpr const char * c_self_name = "exprstate::on_typedescr";
+            const char * exp = get_expect_str();
 
-            throw std::runtime_error(tostr(c_self_name,
-                                           ": unexpected typedescr for parsing state",
-                                           xtag("td", td),
-                                           xtag("state", *this)));
+            this->illegal_input_on_type(c_self_name, td, exp, p_psm);
         }
 
         void
@@ -126,11 +130,14 @@ namespace xo {
                             p_psm->top_exprstate().exs_type()));
 
             constexpr const char * c_self_name = "exprstate::on_formal";
+            const char * exp = this->get_expect_str();
 
-            throw std::runtime_error(tostr(c_self_name,
-                                           ": unexpected formal-arg for parsing state",
-                                           xtag("formal", formal.get()),
-                                           xtag("state", *this)));
+            std::string errmsg = tostr("unexpected formal-arg for parsing state",
+                                       xtag("expecting", exp),
+                                       xtag("formal", formal),
+                                       xtag("state", this->exs_type()));
+
+            p_psm->on_error(c_self_name, std::move(errmsg));
         }
 
         void
@@ -146,11 +153,14 @@ namespace xo {
                             p_psm->top_exprstate().exs_type()));
 
             constexpr const char * c_self_name = "exprstate::on_formal_arglist";
+            const char * exp = get_expect_str();
 
-            throw std::runtime_error(tostr(c_self_name,
-                                           ": unexpected formal-arg for parsing state",
-                                           xtag("argl", argl),
-                                           xtag("state", *this)));
+            std::string errmsg = tostr("unexpected formal-arglist for parsing state",
+                                       xtag("expecting", exp),
+                                       xtag("argl", argl),
+                                       xtag("state", this->exs_type()));
+
+            p_psm->on_error(c_self_name, std::move(errmsg));
         }
 
         void
@@ -381,6 +391,8 @@ namespace xo {
 
             case tokentype::tk_assign:
             case tokentype::tk_yields:
+                assert(false);
+                break;
 
             case tokentype::tk_plus:
             case tokentype::tk_minus:
diff --git a/xo-reader/src/reader/lambda_xs.cpp b/xo-reader/src/reader/lambda_xs.cpp
index 69b4195a..e8111e66 100644
--- a/xo-reader/src/reader/lambda_xs.cpp
+++ b/xo-reader/src/reader/lambda_xs.cpp
@@ -43,6 +43,34 @@ namespace xo {
 
         lambda_xs::lambda_xs() : exprstate(exprstatetype::lambdaexpr) {}
 
+        const char *
+        lambda_xs::get_expect_str() const
+        {
+            /*
+             *   lambda (x : f64) { ... } ;
+             *  ^      ^         ^       ^
+             *  |      |         |       lm_3
+             *  |      |         lm_2
+             *  |      lm_1:
+             *  expect_expression
+             */
+             switch (this->lmxs_type_) {
+             case lambdastatetype::invalid:
+             case lambdastatetype::lm_0:
+             case lambdastatetype::n_lambdastatetype:
+                 assert(false); // impossible
+                 return nullptr;
+             case lambdastatetype::lm_1:
+                 return "lambda-params";
+             case lambdastatetype::lm_2:
+                 return "lambda-body";
+             case lambdastatetype::lm_3:
+                 return "semicolon";
+             }
+
+             return "?expect";
+        }
+
         void
         lambda_xs::on_lambda_token(const token_type & tk,
                                    parserstatemachine * p_psm)