diff --git a/include/xo/reader/define_xs.hpp b/include/xo/reader/define_xs.hpp
index 6e15c21f..3a740a32 100644
--- a/include/xo/reader/define_xs.hpp
+++ b/include/xo/reader/define_xs.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "xo/expression/DefineExpr.hpp"
+#include "xo/expression/ConvertExpr.hpp"
 #include "exprstate.hpp"
 //#include <cstdint>
 
@@ -28,6 +30,7 @@ namespace xo {
          **/
         class define_xs : public exprstate {
         public:
+            using DefineExprAccess = xo::ast::DefineExprAccess;
             using ConvertExprAccess = xo::ast::ConvertExprAccess;
 
         public:
@@ -35,7 +38,7 @@ namespace xo {
             virtual ~define_xs() = default;
 
             static const define_xs * from(const exprstate * x) { return dynamic_cast<const define_xs *>(x); }
-            static std::unique_ptr<define_xs> def_0(rp<DefineExprAccess> def_expr);
+            static std::unique_ptr<define_xs> def_0();
 
             defexprstatetype defxs_type() const { return defxs_type_; }
 
@@ -93,6 +96,8 @@ namespace xo {
              *
              **/
             defexprstatetype defxs_type_;
+            /** scaffold a define-expression here **/
+            rp<DefineExprAccess> def_expr_;
             /** scafford a convert-expression here.
              *  May be nested within a def_expr
              **/
diff --git a/include/xo/reader/exprstate.hpp b/include/xo/reader/exprstate.hpp
index 0d051292..ae1a0bf0 100644
--- a/include/xo/reader/exprstate.hpp
+++ b/include/xo/reader/exprstate.hpp
@@ -6,8 +6,6 @@
 #pragma once
 
 #include "xo/expression/Expression.hpp"
-#include "xo/expression/DefineExpr.hpp"
-#include "xo/expression/ConvertExpr.hpp"
 #include "xo/tokenizer/token.hpp"
 #include <stack>
 //#include <cstdint>
@@ -65,7 +63,6 @@ namespace xo {
         class exprstate {
         public:
             using Expression = xo::ast::Expression;
-            using DefineExprAccess = xo::ast::DefineExprAccess;
             using exprtype = xo::ast::exprtype;
             using token_type = token<char>;
             using TypeDescr = xo::reflect::TypeDescr;
@@ -73,30 +70,28 @@ namespace xo {
         public:
             exprstate() = default;
             exprstate(exprstatetype exs_type,
-                      rp<Expression> candidate_expr,
-                      rp<DefineExprAccess> def_expr)
+                      rp<Expression> candidate_expr)
                 : exs_type_{exs_type},
-                  gen_expr_{std::move(candidate_expr)},
-                  def_expr_{std::move(def_expr)} {}
+                  gen_expr_{std::move(candidate_expr)} {}
             virtual ~exprstate() = default;
 
             static std::unique_ptr<exprstate> expect_toplevel_expression_sequence() {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_toplevel_expression_sequence, nullptr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_toplevel_expression_sequence, nullptr));
             }
             static std::unique_ptr<exprstate> expect_rhs_expression() {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_rhs_expression, nullptr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_rhs_expression, nullptr));
             }
             static std::unique_ptr<exprstate> expect_symbol() {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_symbol, nullptr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_symbol, nullptr));
             }
             static std::unique_ptr<exprstate> expect_type() {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_type, nullptr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::expect_type, nullptr));
             }
             static std::unique_ptr<exprstate> make_expr_progress(rp<Expression> expr) {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::expr_progress, expr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::expr_progress, expr));
             }
             static std::unique_ptr<exprstate> lparen_0() {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::lparen_0, nullptr, nullptr));
+                return std::make_unique<exprstate>(exprstate(exprstatetype::lparen_0, nullptr));
             }
 
             exprstatetype exs_type() const { return exs_type_; }
@@ -162,8 +157,6 @@ namespace xo {
 
             /** generic expression **/
             rp<Expression> gen_expr_;
-            /** scaffold a define-expression here **/
-            rp<DefineExprAccess> def_expr_;
         }; /*exprstate*/
 
         inline std::ostream &
diff --git a/src/reader/define_xs.cpp b/src/reader/define_xs.cpp
index 932d011c..d1f93984 100644
--- a/src/reader/define_xs.cpp
+++ b/src/reader/define_xs.cpp
@@ -5,15 +5,15 @@
 namespace xo {
     namespace scm {
         std::unique_ptr<define_xs>
-        define_xs::def_0(rp<DefineExprAccess> def_expr) {
-            return std::make_unique<define_xs>(define_xs(def_expr));
+        define_xs::def_0() {
+            return std::make_unique<define_xs>(define_xs(DefineExprAccess::make_empty()));
         }
 
         define_xs::define_xs(rp<DefineExprAccess> def_expr)
             : exprstate(exprstatetype::defexpr,
-                        nullptr /*gen_expr*/,
-                        def_expr),
-              defxs_type_{defexprstatetype::def_0}
+                        nullptr /*gen_expr*/),
+              defxs_type_{defexprstatetype::def_0},
+              def_expr_{std::move(def_expr)}
         {}
 
         bool
diff --git a/src/reader/exprstate.cpp b/src/reader/exprstate.cpp
index 5b15ef42..db98d197 100644
--- a/src/reader/exprstate.cpp
+++ b/src/reader/exprstate.cpp
@@ -346,8 +346,7 @@ namespace xo {
                                                xtag("state", *this)));
             }
 
-            p_stack->push_exprstate
-                (define_xs::def_0(DefineExprAccess::make_empty()));
+            p_stack->push_exprstate(define_xs::def_0());
 
             /* todo: replace:
              *   expect_symbol_or_function_signature()
@@ -928,8 +927,6 @@ namespace xo {
         exprstate::print(std::ostream & os) const {
             os << "<exprstate"
                << xtag("type", exs_type_);
-            if (def_expr_)
-                os << xtag("def_expr", def_expr_);
             os << ">";
         }