Split 'xo-tokenizer2/' into commit '48a082cb6b'

git-subtree-dir: xo-tokenizer2
git-subtree-mainline: d684e7408a95b3c5ecf4096413fe143f221bd4e3
git-subtree-split: 48a082cb6b

CMakeLists.txt

@@ -1,8 +1,8 @@
-# xo-tokenizer2/CMakeLists.txt
+# xo-expression2/CMakeLists.txt
 
 cmake_minimum_required(VERSION 3.10)
 
-project(xo_tokenizer2 VERSION 1.0)
+project(xo_expression2 VERSION 1.0)
 enable_language(CXX)
 
 include(GNUInstallDirs)
@@ -20,18 +20,313 @@ add_definitions(${PROJECT_CXX_FLAGS})
 # ----------------------------------------------------------------
 # output targets
 
-add_subdirectory(src/tokenizer2)
-add_subdirectory(example)
-#add_subdirectory(utest)
-xo_export_cmake_config(${PROJECT_NAME} ${PROJECT_VERSION} ${PROJECT_NAME}Targets)
+add_subdirectory(utest)
 
-if (XO_ENABLE_EXAMPLES)
-    install(TARGETS xo_tokenizer2_repl DESTINATION bin/xo/example/tokenizer2)
-endif()
+# note: manual target; generated code committed to git
+xo_add_genfacet(
+    TARGET xo-expression2-facet-symboltable
+    FACET SymbolTable
+    INPUT idl/SymbolTable.json5
+    OUTPUT_HPP_DIR include/xo/expression2
+    OUTPUT_IMPL_SUBDIR detail
+    )
 
 # ----------------------------------------------------------------
-# docs targets depends on all the other library/utest targets
-#
-#add_subdirectory(docs)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-symboltable-localsymtab
+    FACET_PKG xo_expression2
+#    REPR LocalSymtab
+    INPUT idl/ISymbolTable_DLocalSymtab.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-localsymtab
+    FACET_PKG xo_alloc2
+#    REPR LocalSymtab
+    INPUT idl/IGCObject_DLocalSymtab.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-localsymtab
+    FACET_PKG xo_printable2
+#    REPR LocalSymtab
+    INPUT idl/IPrintable_DLocalSymtab.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-symboltable-globalsymtab
+    FACET_PKG xo_expression2
+#    REPR GlobalSymtab
+    INPUT idl/ISymbolTable_DGlobalSymtab.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-globalsymtab
+    FACET_PKG xo_alloc2
+#    REPR GlobalSymtab
+    INPUT idl/IGCObject_DGlobalSymtab.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-globalsymtab
+    FACET_PKG xo_printable2
+#    REPR GlobalSymtab
+    INPUT idl/IPrintable_DGlobalSymtab.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacet(
+    TARGET xo-expression2-facet-expression
+    FACET Expression
+    INPUT idl/Expression.json5
+    OUTPUT_HPP_DIR include/xo/expression2
+    OUTPUT_IMPL_SUBDIR detail
+    )
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-constant
+    FACET_PKG xo_expression2
+#    REPR Constant
+    INPUT idl/IExpression_DConstant.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-constant
+    FACET_PKG xo_alloc2
+#    REPR Constant
+    INPUT idl/IGCObject_DConstant.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-constant
+    FACET_PKG xo_printable2
+#    REPR Constant
+    INPUT idl/IPrintable_DConstant.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-variable
+    FACET_PKG xo_expression2
+#    REPR Variable
+    INPUT idl/IExpression_DVariable.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-variable
+    FACET_PKG xo_alloc2
+#    REPR Variable
+    INPUT idl/IGCObject_DVariable.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-variable
+    FACET_PKG xo_printable2
+#    REPR Variable
+    INPUT idl/IPrintable_DVariable.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-typename
+    FACET_PKG xo_alloc2
+#    REPR Typename
+    INPUT idl/IGCObject_DTypename.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-typename
+    FACET_PKG xo_printable2
+#    REPR Typename
+    INPUT idl/IPrintable_DTypename.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-varref
+    FACET_PKG xo_expression2
+#    REPR VarRef
+    INPUT idl/IExpression_DVarRef.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-varref
+    FACET_PKG xo_alloc2
+#    REPR VarRef
+    INPUT idl/IGCObject_DVarRef.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-varref
+    FACET_PKG xo_printable2
+#    REPR VarRef
+    INPUT idl/IPrintable_DVarRef.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-defineexpr
+    FACET_PKG xo_expression2
+#    REPR DefineExpr
+    INPUT idl/IExpression_DDefineExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-defineexpr
+    FACET_PKG xo_alloc2
+#    REPR DefineExpr
+    INPUT idl/IGCObject_DDefineExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-defineexpr
+    FACET_PKG xo_printable2
+#    REPR DefineExpr
+    INPUT idl/IPrintable_DDefineExpr.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-applyexpr
+    FACET_PKG xo_expression2
+#    REPR ApplyExpr
+    INPUT idl/IExpression_DApplyExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-applyexpr
+    FACET_PKG xo_alloc2
+#    REPR ApplyExpr
+    INPUT idl/IGCObject_DApplyExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-applyexpr
+    FACET_PKG xo_printable2
+#    REPR ApplyExpr
+    INPUT idl/IPrintable_DApplyExpr.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-lambdaexpr
+    FACET_PKG xo_expression2
+#    REPR LambdaExpr
+    INPUT idl/IExpression_DLambdaExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-lambdaexpr
+    FACET_PKG xo_alloc2
+#    REPR LambdaExpr
+    INPUT idl/IGCObject_DLambdaExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-lambdaexpr
+    FACET_PKG xo_printable2
+#    REPR LambdaExpr
+    INPUT idl/IPrintable_DLambdaExpr.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-ifelseexpr
+    FACET_PKG xo_expression2
+#    REPR IfElseExpr
+    INPUT idl/IExpression_DIfElseExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-ifelseexpr
+    FACET_PKG xo_alloc2
+    INPUT idl/IGCObject_DIfElseExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-ifelseexpr
+    FACET_PKG xo_printable2
+    INPUT idl/IPrintable_DIfElseExpr.json5
+)
+
+# ----------------------------------------------------------------
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-expression-sequenceexpr
+    FACET_PKG xo_expression2
+    INPUT idl/IExpression_DSequenceExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-gcobject-sequenceexpr
+    FACET_PKG xo_alloc2
+    INPUT idl/IGCObject_DSequenceExpr.json5
+)
+
+# note: manual target; generated code committed to git
+xo_add_genfacetimpl(
+    TARGET xo-expression2-facetimpl-printable-sequenceexpr
+    FACET_PKG xo_printable2
+    INPUT idl/IPrintable_DSequenceExpr.json5
+)
+
+# ----------------------------------------------------------------
+
+xo_add_genfacet_all(xo-expression2-genfacet-all)
+
+# ----------------------------------------------------------------
+# shared library
+
+add_subdirectory(src/expression2)
+
+# ----------------------------------------------------------------
+# cmake helper (for external xo-expression2 users)
+
+xo_export_cmake_config(${PROJECT_NAME} ${PROJECT_VERSION} ${PROJECT_NAME}Targets)
 
 # end CMakeLists.txt

cmake/xo_expression2Config.cmake.in

@@ -4,10 +4,15 @@ include(CMakeFindDependencyMacro)
 
 # note: changes to find_dependency() calls here
 #       must coordinate with xo_dependency() calls
-#       in src/tokenizer2/CMakeLists.txt
+#       in CMakeLists.txt
 #
-find_dependency(xo_stringtable2)
-find_dependency(xo_arena)
+find_dependency(xo_type)
+find_dependency(xo_gc)
+find_dependency(reflect)
+find_dependency(xo_procedure2)
+find_dependency(xo_printable2)
+find_dependency(xo_flatstring)
+find_dependency(cmake)
 find_dependency(indentlog)
 
 include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")

example/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(tokenrepl)

example/tokenrepl/CMakeLists.txt

@@ -1,15 +0,0 @@
-# xo-tokenizer2/example/tokenrepl/CMakeLists.txt
-
-set(SELF_EXE xo_tokenizer2_repl)
-set(SELF_SRCS tokenrepl.cpp)
-
-if (XO_ENABLE_EXAMPLES)
-    xo_add_executable(${SELF_EXE} ${SELF_SRCS})
-    xo_self_dependency(${SELF_EXE} xo_tokenizer2)
-    xo_external_target_dependency(${SELF_EXE} replxx replxx::replxx)
-
-    find_package(Threads REQUIRED)   # replxx needs this
-    target_link_libraries(${SELF_EXE} PUBLIC Threads::Threads)
-endif()
-
-# end CMakeLists.txt

example/tokenrepl/tokenrepl.cpp

@@ -1,128 +0,0 @@
-/** @file tokenrepl.cpp **/
-
-#include <xo/tokenizer2/Tokenizer.hpp>
-#include <xo/tokenizer2/Token.hpp>
-#include <xo/tokenizer2/tokentype.hpp>
-#include <xo/arena/span.hpp>
-#include <xo/indentlog/log_config.hpp>
-#include <replxx.hxx>
-#include <iostream>
-#include <unistd.h> // for isatty
-
-// presumeably replxx assumes input is a tty
-//
-bool replxx_getline(bool interactive,
-                    std::size_t parser_stack_size,
-                    replxx::Replxx & rx,
-                    const char ** p_input)
-{
-    using namespace std;
-
-    char const * prompt = "";
-
-    if (interactive) {
-        if (parser_stack_size <= 1)
-            prompt = "> ";
-        else
-            prompt = ". ";
-    }
-
-    const char * input_cstr = rx.input(prompt);
-
-    bool retval = (input_cstr != nullptr);
-
-    if (retval) {
-        //cerr << "got reval->true" << endl;
-
-        *p_input = input_cstr;
-
-    } else {
-        //cerr << "got retval->false" << endl;
-    }
-
-    rx.history_add(input_cstr);
-
-    return retval;
-}
-
-int
-main() {
-    using xo::scm::Tokenizer;
-    using xo::scm::operator<<;
-    using xo::mm::CircularBufferConfig;
-    using xo::mm::span;
-    using xo::scope;
-    using xo::xtag;
-    using replxx::Replxx;
-
-    using namespace std;
-
-    using span_type = span<const char>;
-
-    xo::log_config::min_log_level = xo::log_level::severe;
-
-    bool interactive = isatty(STDIN_FILENO);
-
-    Replxx rx;
-    rx.set_max_history_size(1000);
-    rx.history_load("repl_history.txt");
-
-    constexpr bool c_debug_flag = true;
-    scope log(XO_DEBUG(c_debug_flag));
-
-    Tokenizer tkz(CircularBufferConfig{.name_ = "tokenrepl-input",
-                                       .max_capacity_ = 4*1024,
-                                       .max_captured_span_ = 128},
-                  c_debug_flag);
-
-    const char * input_cstr = nullptr;;
-
-    size_t line_no = 1;
-
-    constexpr std::size_t c_maxlines = 25;
-
-    while (replxx_getline(interactive, 0 /*parser_stack_size*/, rx, &input_cstr))
-    {
-        //cout << "input: " << input << endl;
-
-        auto input_ext = Tokenizer::span_type::from_cstr(input_cstr);
-
-        // reminder: input may contain multiple tokens
-        auto [error, input] = tkz.buffer_input_line(input_ext, false /*!eof*/);
-
-        if (log) {
-            log(xtag("msg", "buffered input line"));
-            log(xtag("input", input));
-        }
-
-        while (!input.empty())
-        {
-            auto [tk, consumed, error] = tkz.scan(input);
-
-            log && log(xtag("consumed", consumed), xtag("tk", tk));
-
-            if (tk.is_valid()) {
-                cout << tk << endl;
-            } else if (error.is_error()) {
-                cout << "tokenizer error: " << endl;
-
-                error.report(cout);
-
-                break;
-            }
-
-            input = input.after_prefix(consumed);
-        }
-
-        /* here: input.empty() or error encountered */
-
-        ++line_no;
-
-        if (line_no > c_maxlines) {
-            cout << "always exit after " << c_maxlines << " lines of input" << endl;
-            break;
-        }
-    }
-}
-
-/** end tokenrepl.cpp */

idl/Expression.json5

@@ -0,0 +1,74 @@
+{
+    mode: "facet",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"TypeRef.hpp\"",
+                "\"exprtype.hpp\"",
+                "<xo/reflect/TypeDescr.hpp>"],
+    // extra includes in Expression.hpp, if any
+    user_hpp_includes: [],
+    namespace1: "xo",
+    namespace2: "scm",
+    // text after includes, before AExpression
+    pretext: [ "// {pretext} here" ],
+    facet: "Expression",
+    detail_subdir: "detail",
+    brief: "a schematika expression",
+    using_doxygen: true,
+    doc: [
+        "Representation for executable Schematika expressions"
+    ],
+    types: [
+        // using TypeDescr = xo::reflect::TypeDescr;
+        {
+            name: "TypeDescr",
+            doc: ["struct describing a type"],
+            definition: "xo::reflect::TypeDescr"
+        },
+    ],
+    const_methods: [
+        {
+            name: "extype",
+            doc: ["expression type (constant | apply | ..)"],
+            return_type: "exprtype",
+            args: [],
+            const: true,
+            noexcept: true,
+            attributes: [],
+        },
+        {
+            name: "typeref",
+            doc: ["placeholder for type giving possible values for this expression"],
+            return_type: "TypeRef",
+            args: [],
+            const: true,
+            noexcept: true,
+            attributes: [],
+        },
+        {
+            name: "valuetype",
+            doc: ["type giving possible values for this expression. Maybe null before typecheck"],
+            return_type: "TypeDescr",
+            args: [],
+            const: true,
+            noexcept: true,
+            attributes: [],
+        },
+    ],
+    nonconst_methods: [
+        {
+            name: "assign_valuetype",
+            doc: ["assing to valuetype member. Useful when scaffolding expressions"],
+            return_type: "void",
+            args: [
+                // void assign_valuetype(TypeDescr td)
+                {type: "TypeDescr", name: "td"},
+            ],
+            const: false,
+            noexcept: true,
+            attributes: [],
+        }
+    ],
+    router_facet_explicit_content: [ ],
+}

idl/IExpression_DApplyExpr.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DApplyExpr state",
+    using_doxygen: true,
+    repr: "DApplyExpr",
+    doc: ["doc for IExpression+DApplyExpr" ],
+}

idl/IExpression_DConstant.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DConstant state",
+    using_doxygen: true,
+    repr: "DConstant",
+    doc: ["doc for something or other IExpression+DConstant" ],
+}

idl/IExpression_DDefineExpr.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DDefineExpr state",
+    using_doxygen: true,
+    repr: "DDefineExpr",
+    doc: ["doc for IExpression+DDefineExpr" ],
+}

idl/IExpression_DIfElseExpr.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DIfElseExpr state",
+    using_doxygen: true,
+    repr: "DIfElseExpr",
+    doc: ["doc for IExpression+DIfElseExpr" ],
+}

idl/IExpression_DLambdaExpr.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DLambdaExpr state",
+    using_doxygen: true,
+    repr: "DLambdaExpr",
+    doc: ["doc for IExpression+DLambdaExpr" ],
+}

idl/IExpression_DSequenceExpr.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DSequenceExpr state",
+    using_doxygen: true,
+    repr: "DSequenceExpr",
+    doc: ["doc for something or other IExpression+DSequenceExpr" ],
+}

idl/IExpression_DVarRef.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DVarRef state",
+    using_doxygen: true,
+    repr: "DVarRef",
+    doc: ["doc for IExpression+DVarRef" ],
+}

idl/IExpression_DVariable.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2/facet",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "variable",
+    includes: [ "\"Expression.hpp\"" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Expression.json5",
+    brief: "provide AExpression interface for DVariable state",
+    using_doxygen: true,
+    repr: "DVariable",
+    doc: ["doc for IExpression+DVariable" ],
+}

idl/IGCObject_DApplyExpr.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DApplyExpr",
+    using_doxygen: true,
+    repr: "DApplyExpr",
+    doc: [ "implement AGCObject for DApplyExpr" ],
+}

idl/IGCObject_DConstant.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DConstant",
+    using_doxygen: true,
+    repr: "DConstant",
+    doc: [ "implement AGCObject for DConstant" ],
+}

idl/IGCObject_DDefineExpr.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "define",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DDefineExpr",
+    using_doxygen: true,
+    repr: "DDefineExpr",
+    doc: [ "implement AGCObject for DDefineExpr" ],
+}

idl/IGCObject_DGlobalSymtab.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DGlobalSymtab",
+    using_doxygen: true,
+    repr: "DGlobalSymtab",
+    doc: [ "implement AGCObject for DGlobalSymtab" ],
+}

idl/IGCObject_DIfElseExpr.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DIfElseExpr",
+    using_doxygen: true,
+    repr: "DIfElseExpr",
+    doc: [ "implement AGCObject for DIfElseExpr" ],
+}

idl/IGCObject_DLambdaExpr.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DLambdaExpr",
+    using_doxygen: true,
+    repr: "DLambdaExpr",
+    doc: [ "implement AGCObject for DLambdaExpr" ],
+}

idl/IGCObject_DLocalSymtab.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DLocalSymtab",
+    using_doxygen: true,
+    repr: "DLocalSymtab",
+    doc: [ "implement AGCObject for DLocalSymtab" ],
+}

idl/IGCObject_DSequenceExpr.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DSequenceExpr",
+    using_doxygen: true,
+    repr: "DSequenceExpr",
+    doc: [ "implement AGCObject for DSequenceExpr" ],
+}

idl/IGCObject_DTypename.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "typename",
+    includes: [
+//        "<xo/alloc2/GCObject.hpp>",
+//        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DTypename",
+    using_doxygen: true,
+    repr: "DTypename",
+    doc: [ "implement AGCObject for DTypename" ],
+}

idl/IGCObject_DVarRef.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DVarRef",
+    using_doxygen: true,
+    repr: "DVarRef",
+    doc: [ "implement AGCObject for DVarRef" ],
+}

idl/IGCObject_DVariable.json5

@@ -0,0 +1,18 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2/facet",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "variable",
+    includes: [
+        "<xo/alloc2/GCObject.hpp>",
+        "<xo/alloc2/Allocator.hpp>"
+    ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/GCObject.json5",
+    brief: "provide AGCObject interface for DVariable",
+    using_doxygen: true,
+    repr: "DVariable",
+    doc: [ "implement AGCObject for DVariable" ],
+}

idl/IPrintable_DApplyExpr.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DApplyExpr",
+    using_doxygen: true,
+    repr: "DApplyExpr",
+    doc: [ "implement APrintable for DApplyExpr" ],
+}

idl/IPrintable_DConstant.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DConstant",
+    using_doxygen: true,
+    repr: "DConstant",
+    doc: [ "implement APrintable for DConstant" ],
+}

idl/IPrintable_DDefineExpr.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DDefineExpr",
+    using_doxygen: true,
+    repr: "DDefineExpr",
+    doc: [ "implement APrintable for DDefineExpr" ],
+}

idl/IPrintable_DGlobalSymtab.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DGlobalSymtab",
+    using_doxygen: true,
+    repr: "DGlobalSymtab",
+    doc: [ "implement APrintable for DGlobalSymtab" ],
+}

idl/IPrintable_DIfElseExpr.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DIfElseExpr",
+    using_doxygen: true,
+    repr: "DIfElseExpr",
+    doc: [ "implement APrintable for DIfElseExpr" ],
+}

idl/IPrintable_DLambdaExpr.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DLambdaExpr",
+    using_doxygen: true,
+    repr: "DLambdaExpr",
+    doc: [ "implement APrintable for DLambdaExpr" ],
+}

idl/IPrintable_DLocalSymtab.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DLocalSymtab",
+    using_doxygen: true,
+    repr: "DLocalSymtab",
+    doc: [ "implement APrintable for DLocalSymtab" ],
+}

idl/IPrintable_DSequenceExpr.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DSequenceExpr",
+    using_doxygen: true,
+    repr: "DSequenceExpr",
+    doc: [ "implement APrintable for DSequenceExpr" ],
+}

idl/IPrintable_DTypename.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "typename",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DTypename",
+    using_doxygen: true,
+    repr: "DTypename",
+    doc: [ "implement APrintable for DTypename" ],
+}

idl/IPrintable_DVarRef.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "detail",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DVarRef",
+    using_doxygen: true,
+    repr: "DVarRef",
+    doc: [ "implement APrintable for DVarRef" ],
+}

idl/IPrintable_DVariable.json5

@@ -0,0 +1,16 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2/facet",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "variable",
+    includes: [ "<xo/printable2/Printable.hpp>",
+                "<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/Printable.json5",
+    brief: "provide APrintable interface for DVariable",
+    using_doxygen: true,
+    repr: "DVariable",
+    doc: [ "implement APrintable for DVariable" ],
+}

idl/ISymbolTable_DGlobalSymtab.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [ ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/SymbolTable.json5",
+    brief: "provide ASymbolTable interface for DGlobalSymtab",
+    using_doxygen: true,
+    repr: "DGlobalSymtab",
+    doc: [ "implement ASymbolTable for DGlobalSymtab" ],
+}

idl/ISymbolTable_DLocalSymtab.json5

@@ -0,0 +1,15 @@
+{
+    mode: "implementation",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [ ],
+    local_types: [ ],
+    namespace1: "xo",
+    namespace2: "scm",
+    facet_idl: "idl/SymbolTable.json5",
+    brief: "provide ASymbolTable interface for DLocalSymtab",
+    using_doxygen: true,
+    repr: "DLocalSymtab",
+    doc: [ "implement ASymbolTable for DLocalSymtab" ],
+}

idl/SymbolTable.json5

@@ -0,0 +1,63 @@
+{
+    mode: "facet",
+    output_cpp_dir: "src/expression2",
+    output_hpp_dir: "include/xo/expression2",
+    output_impl_subdir: "symtab",
+    includes: [
+        "\"Binding.hpp\"",
+        "\"DUniqueString.hpp\""
+    ],
+    // extra includes in SymbolTable.hpp, if any
+    user_hpp_includes: [],
+    namespace1: "xo",
+    namespace2: "scm",
+    // text after includes, before ASymbolTable
+    pretext: [ "// {pretext} here" ],
+    facet: "SymbolTable",
+    detail_subdir: "symtab",
+    brief: "symbol table derived from a set of schematika expressions",
+    using_doxygen: true,
+    doc: [
+        "Map symbols to schematika expressions. Output of schematika parser"
+    ],
+    types: [
+        // { name: string, doc: [ string ], definition: string },
+    ],
+    const_methods: [
+
+        {
+            // bool is_global_symtab() const noexcept;
+            name: "is_global_symtab",
+            doc: ["true iff this is toplevel (global) symbol table."],
+            return_type: "bool",
+            args: [],
+            const: true,
+            noexcept: true,
+            attributes: [],
+        },
+
+        {
+            // Binding lookup_binding(const DUniqueString * sym) const noexcept;
+            name: "lookup_binding",
+            doc: ["report ingredients needed to address variable at runtime."],
+            return_type: "Binding",
+            args: [
+                {type: "const DUniqueString *", name: "sym"},
+            ],
+            const: true,
+            noexcept: true,
+            attributes: [],
+        },
+
+        // //
+        // obj<AExpression> lookup_var(const DUniqueString * sym) const noexcept;
+
+        // //
+        // obj<AExpression> lookup_local(const DUniqueString * sym) const noexcept;
+    ],
+    nonconst_methods: [
+        // // Variable gives both {name, type}
+        // void upsert_local(DVariable * target) = 0;
+    ],
+    router_facet_explicit_content: [ ],
+}

include/xo/expression2/ApplyExpr.hpp

@@ -0,0 +1,13 @@
+/** @file ApplyExpr.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DApplyExpr.hpp"
+#include "detail/IExpression_DApplyExpr.hpp"
+#include "detail/IGCObject_DApplyExpr.hpp"
+#include "detail/IPrintable_DApplyExpr.hpp"
+
+/* end ApplyExpr.hpp */

include/xo/expression2/Binding.hpp

@@ -0,0 +1,65 @@
+/** @file Binding.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include <iostream>
+#include <cstdint>
+
+namespace xo {
+    namespace scm {
+        class Binding {
+        public:
+            using slot_type = int32_t;
+
+            static constexpr int32_t c_link_sentinel = -2;
+            static constexpr int32_t c_link_global = -1;
+
+        public:
+            Binding() : i_link_{-2}, j_slot_{-1} {}
+            Binding(int32_t i_link, int32_t j_slot)
+                : i_link_{i_link}, j_slot_{j_slot} {}
+
+            static Binding null() { return Binding(); }
+            /** global bindings are located by symbol name **/
+            static Binding global(int32_t j_slot) { return Binding(c_link_global, j_slot); }
+            static Binding local(int32_t j_slot) { return Binding(0, j_slot); }
+            static Binding relative(int32_t i_link, Binding def);
+
+            bool is_null() const {
+                return (i_link_ == c_link_sentinel) && (j_slot_ == -1);
+            }
+            bool is_global() const { return i_link_ == c_link_global; }
+            bool is_local() const { return (i_link_ == 0) && (j_slot_ >= 0); }
+
+            int32_t i_link() const noexcept { return i_link_; }
+            int32_t j_slot() const noexcept { return j_slot_; }
+
+            /** print human-readable repr to stream @p os **/
+            void print(std::ostream & os) const;
+
+        private:
+            /**
+             *  >= 0: number of parent links to traverse
+             *        to a fixed-size frame
+             *    -1: resolve globally
+             *    -2: sentinel (binding info not computed)
+             **/
+            int32_t i_link_ = c_link_sentinel;
+            /** if @ref i_link_ >= 0, frame offset
+             *  (in 'variables' not bytes).
+             *  ignored if @ref i_link_ is global
+             **/
+            int32_t j_slot_ = -1;
+        };
+
+        inline std::ostream & operator<< (std::ostream & os, Binding x) {
+            x.print(os);
+            return os;
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* Binding.hpp */

include/xo/expression2/Constant.hpp

@@ -0,0 +1,13 @@
+/** @file Constant.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DConstant.hpp"
+#include "detail/IExpression_DConstant.hpp"
+#include "detail/IGCObject_DConstant.hpp"
+#include "detail/IPrintable_DConstant.hpp"
+
+/* end Constant.hpp */

include/xo/expression2/DApplyExpr.hpp

@@ -0,0 +1,113 @@
+/** @file DApplyExpr.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/object2/DArray.hpp>
+#include <xo/reflect/TypeDescr.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    namespace scm {
+
+        /** @class DApplyExpr
+         *  @brief syntax for a procedure/function call
+         **/
+        class DApplyExpr {
+        public:
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+            using ppindentinfo = xo::print::ppindentinfo;
+            using size_type = std::uint32_t;
+
+        public:
+            /** @defgroup scm-applyexpr-constructors **/
+            ///@{
+
+            /** construct empty instance, but with argument expressions empty **/
+            DApplyExpr(TypeRef typeref,
+                       obj<AExpression> fn_expr,
+                       size_type n_args);
+
+            /** create apply for function with 2 arguments **/
+            static obj<AExpression,DApplyExpr> make2(obj<AAllocator> mm,
+                                                     TypeRef typeref,
+                                                     obj<AExpression> fn_expr,
+                                                     obj<AExpression> arg1,
+                                                     obj<AExpression> arg2);
+
+            /** create apply for function with 2 arguments **/
+            static DApplyExpr * _make2(obj<AAllocator> mm,
+                                       TypeRef typeref,
+                                       obj<AExpression> fn_expr,
+                                       obj<AExpression> arg1,
+                                       obj<AExpression> arg2);
+
+            /** scaffold incomplete instance.
+             *  apply-expr using memory from @p mm.
+             *  will construct instance with space for @p n_args arguments
+             *  but expressions left empty.
+             *  use @ref assign_arg for all arguments to complete.
+             **/
+            static DApplyExpr * scaffold(obj<AAllocator> mm,
+                                         TypeRef typeref,
+                                         obj<AExpression> fn_expr,
+                                         size_type n_args);
+            void assign_arg(size_type i_arg, obj<AExpression> expr);
+
+            ///@}
+            /** @defgroup scm-applyexpr-access-methods **/
+            ///@{
+
+            obj<AExpression>  fn() const noexcept { return fn_; }
+            size_type n_args() const noexcept { return n_args_; }
+            obj<AExpression> arg(size_type i) const;
+
+            ///@}
+            /** @defgroup scm-applyexpr-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::apply; }
+            TypeRef typeref() const noexcept { return typeref_; }
+            TypeDescr valuetype() const noexcept { return typeref_.td(); }
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-applyexpr-gcobject-facet **/
+            ///@{
+
+            DApplyExpr * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-applyexpr-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** expression value always has type consistent
+             *  with this description
+             **/
+            TypeRef typeref_;
+            /** expression for function/procedure to invoke **/
+            obj<AExpression> fn_;
+            /** number of arguments (not counting @ref fn_ **/
+            size_type n_args_ = 0;
+            /** args_[i] is expression for i'th argument to @ref fn_ **/
+            obj<AExpression> args_[];
+        };
+    }
+}
+
+/* end DApplyExpr.hpp */

include/xo/expression2/DConstant.hpp

@@ -0,0 +1,91 @@
+/** @file DConstant.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/reflect/TaggedPtr.hpp>
+
+namespace xo {
+    namespace scm {
+        /** @class DConstant
+         *  @brief Schematika expression respresenting a literal constant
+         **/
+        struct DConstant {
+        public:
+            using TaggedPtr = xo::reflect::TaggedPtr;
+            using TypeDescr = xo::reflect::TypeDescr;
+            using AGCObject = xo::mm::AGCObject;
+            using VisitReason = xo::mm::VisitReason;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using AAllocator = xo::mm::AAllocator;
+            using typeseq = xo::reflect::typeseq;
+            using ppindentinfo = xo::print::ppindentinfo;
+
+        public:
+            explicit DConstant(obj<AGCObject> value) noexcept;
+
+            /** create isntance
+             *  @p mm     memory allocator
+             *  @p value  literal constant
+             **/
+            static obj<AExpression,DConstant> make(obj<AAllocator> mm,
+                                                   obj<AGCObject> value);
+
+            /** create instance
+             *  @p mm     memory allocator
+             *  @p value  literal constant
+             **/
+            static DConstant * _make(obj<AAllocator> mm,
+                                     obj<AGCObject> value);
+
+            bool is_resolved() const noexcept { return typeref_.is_resolved(); }
+
+            obj<AGCObject> value() const noexcept { return value_; }
+            TypeDescr value_td() const noexcept { return typeref_.td(); }
+            TaggedPtr value_tp() const noexcept { return TaggedPtr(typeref_.td(), value_.data()); }
+
+            /** @defgroup scm-constant-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::constant; }
+            TypeRef typeref() const noexcept { return typeref_; }
+            TypeDescr valuetype() const noexcept { return typeref_.td(); }
+            void assign_valuetype(TypeDescr td) noexcept { typeref_.resolve(td); }
+
+            ///@}
+            /** @defgroup scm-constant-gcobject-facet **/
+            ///@{
+
+            DConstant * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-constant-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            static TypeDescr _lookup_td(typeseq tseq);
+
+        private:
+            /** type for value of this expression
+             *  or unification breadcrumb before unification
+             **/
+            TypeRef typeref_;
+            /** literal value **/
+            obj<AGCObject> value_;
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DConstant.hpp */

include/xo/expression2/DDefineExpr.hpp

@@ -0,0 +1,108 @@
+/** @file DDefineExpr.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "DVariable.hpp"
+#include <xo/alloc2/Allocator.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    namespace scm {
+        class DUniqueString; // see DUniqueString.hpp
+
+        /** @class DDefineExpr
+         *  @brief an expression that introduces a variable.
+         *
+         *  Variable may optionally be declared with a type,
+         *  and may come with an expression specifying an initial value
+         **/
+        class DDefineExpr {
+        public:
+            using ppindentinfo = xo::print::ppindentinfo;
+            using ACollector = xo::mm::ACollector;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+
+        public:
+            /** @defgroup scm-defineexpr-constructors **/
+            ///@{
+
+            /** create instance: define-expr using memory from @p mm
+             *  with lhs name @p lhs_name and rhs expression @p rhs_expr
+             **/
+            static DDefineExpr * make(obj<AAllocator> mm,
+                                      const DUniqueString * lhs_name,
+                                      obj<AExpression> rhs_expr);
+            /** create empty skeleton. Rely on this for parsing
+             **/
+            static DDefineExpr * make_empty(obj<AAllocator> mm);
+
+            DDefineExpr(DVariable * lhs_var,
+                        obj<AExpression> rhs);
+
+            ///@}
+            /** @defgroup scm-definexpr-access-methods **/
+            ///@{
+
+            DVariable * lhs() const { return lhs_var_; }
+            obj<AExpression> rhs() const noexcept { return rhs_; }
+            const DUniqueString * name() const noexcept;
+
+            ///@}
+            /** @defgroup scm-definexpr-bookkeeping-methods **/
+            ///@{
+
+            void assign_lhs_name(const DUniqueString * name);
+            void assign_rhs(obj<AExpression> rhs);
+
+            ///@}
+            /** @defgroup scm-defineexpr-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::define; }
+            TypeRef typeref() const noexcept { return lhs_var_->typeref(); }
+            TypeDescr valuetype() const noexcept { return lhs_var_->typeref().td(); }
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-defineexpr-gcobject-facet **/
+            ///@{
+
+            DDefineExpr * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-defineexpr-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** @defgrouop scm-defineexpr-instance-vars **/
+            ///@{
+
+            /** variable being defined by this expression.
+             **/
+            DVariable * lhs_var_ = nullptr;
+
+            /** expression for initial value of this expression
+             **/
+            obj<AExpression> rhs_;
+
+            // std::set<std::string> free_var_set_;
+
+            ///@}
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DDefineExpr.hpp */

include/xo/expression2/DGlobalSymtab.hpp

@@ -0,0 +1,161 @@
+/** @file DGlobalSymtab.hpp
+*
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Binding.hpp"
+#include "DVariable.hpp"
+#include "DTypename.hpp"
+#include <xo/object2/DArray.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/alloc2/dp.hpp>
+#include <xo/arena/DArenaHashMap.hpp>
+
+namespace xo {
+    namespace scm {
+        class DUniqueString;
+
+        /** @class DGlobalSymtab
+         *  @brief symbol table for toplevel environment
+         *
+         *  We're using DArenaHashMap to store <key,binding> pairs.
+         *  Both of these are outside GC-space, so we don't need collector
+         *  to traverse these.
+         **/
+        class DGlobalSymtab {
+        public:
+            using key_type = const DUniqueString *;
+            using value_type = Binding;
+            using ArenaHashMapConfig = xo::map::ArenaHashMapConfig;
+            using repr_type = xo::map::DArenaHashMap<key_type, Binding::slot_type>;
+            using AGCObject = xo::mm::AGCObject;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using MemorySizeVisitor = xo::mm::MemorySizeVisitor;
+            using ppindentinfo = xo::print::ppindentinfo;
+            using size_type = std::uint32_t;
+
+        public:
+            /** @defgroup scm-globalsymtab-ctors constructors **/
+            ///@{
+
+            DGlobalSymtab(dp<repr_type> var_map, DArray * vars,
+                          dp<repr_type> type_map, DArray * types);
+
+            /** move constructor (needed because dp<> deletes copy ctor) **/
+            DGlobalSymtab(DGlobalSymtab && other);
+
+            /** create instance.
+             *  Use memory from @p fixed_mm for @ref map_.
+             *  Use memory from @p mm for DGlobalSymtab instance.
+             *  Hashmap for variables per @p var_cfg; for types per @p type_cfg.
+             **/
+            static DGlobalSymtab * _make(obj<AAllocator> mm,
+                                         obj<AAllocator> fixed_mm,
+                                         const ArenaHashMapConfig & var_cfg,
+                                         const ArenaHashMapConfig & type_cfg);
+
+            /** like _make(..), but create fop **/
+            static obj<AGCObject,DGlobalSymtab> make(obj<AAllocator> mm,
+                                                     obj<AAllocator> fixed_mm,
+                                                     const ArenaHashMapConfig & var_cfg,
+                                                     const ArenaHashMapConfig & type_cfg);
+
+            /** non-trivial destructor for @ref map_ **/
+            ~DGlobalSymtab() = default;
+
+            ///@}
+            /** @defgroup scm-globalsymtab-access-methods access methods **/
+            ///@{
+
+            size_type n_vars() const noexcept { return var_map_->size(); }
+            size_type var_capacity() const noexcept { return var_map_->capacity(); }
+
+            /** visit symtab-owned memory pools; call visitor(info) for each **/
+            void visit_pools(const MemorySizeVisitor & visitor) const;
+
+            /** lookup global symbol with name @p sym **/
+            DVariable * lookup_variable(const DUniqueString * sym) const noexcept;
+
+            /** lookup global typename with name @p sym **/
+            DTypename * lookup_typename(const DUniqueString * sym) const noexcept;
+
+            ///@}
+            /** @defgroup scm-globalsymtab-general-methods general methods **/
+            ///@{
+
+            /** update this symtab to associate @p var with @c var->name().
+             *  If there was a previous variable with the same name,
+             *  replace it with @p var.
+             **/
+            void upsert_variable(obj<AAllocator> mm,
+                                 DVariable * var);
+
+            /** update this symtab to associate typename @p type with @c type->name().
+             *  If there was a previous type with the same name, replace it with
+             *  @p type.
+             **/
+            void upsert_typename(obj<AAllocator> mm,
+                                 DTypename * type);
+
+            ///@}
+            /** @defgroup scm-globalsymtab-symboltable-facet symboltable facet **/
+            ///@{
+
+            /** true for global symbol table **/
+            bool is_global_symtab() const noexcept { return true; }
+
+            /** lookup binding for variable @p sym **/
+            Binding lookup_binding(const DUniqueString * sym) const noexcept;
+
+            ///@}
+            /** @defgroup scm-globalsymtab-gcobject-facet gcobject facet **/
+            ///@{
+
+            DGlobalSymtab * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-globalsymtab-printable-facet printable facet **/
+            ///@{
+
+            /** pretty-printing support **/
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** map variable symbol -> index into @ref vars_.
+             *  Minor point: storing offsets instead of Variables allows us to:
+             *  omit hash-map iteration during GC.
+             *  Savings when map_ slots sparsely populated.
+             **/
+            dp<repr_type> var_map_;
+
+            /** array of variables.
+             *  When S is a unique-string for a global symbol, then:
+             *  1. var_map_[S] is unique global index i(S) for S.
+             *  2. vars_[i(S)] is variable-expr var(S) for S
+             *  3. var(S)->name == S
+             **/
+            DArray * vars_ = nullptr;
+
+            /** map type name -> index values into @ref types_ **/
+            dp<repr_type> type_map_;
+
+            /** array of types.
+             *  When T is a unique-string for a globally-defined type, then:
+             *  1. type_map_[T] is unique global index i(T) for T.
+             *  2. types_[i(T)] is type type(T) for T
+             *  3. type(T)->name == T
+             **/
+            DArray * types_ = nullptr;
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DGlobalSymtab.hpp */

include/xo/expression2/DIfElseExpr.hpp

@@ -0,0 +1,248 @@
+/** @file DIfElseExpr.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include <string>
+
+namespace xo {
+    namespace scm {
+
+        /** @class DIfExpr
+         *  @brief abstract syntax tree for a function definition
+         **/
+        class DIfElseExpr {
+        public:
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+            using ppindentinfo = xo::print::ppindentinfo;
+
+        public:
+            /** @defgroup scm-ifelseexpr-constructors **/
+            ///@{
+
+            /**
+             *  @p ifexpr_type  type for value produced by if-expression.
+             *                  same as both when_true->valuetype() and
+             *                  when_false->valuetype().
+             *  @p test   test-expression;  always execute
+             *  @p when_true  then-branch;  executes only when test succeeds
+             *  @p when_false else-branch;  executes only when test fails
+             **/
+            DIfElseExpr(TypeRef ifexpr_type,
+                        obj<AExpression> test_expr,
+                        obj<AExpression> when_true,
+                        obj<AExpression> when_false);
+
+            /** create if-else expression using memory from @p mm.
+             *  @p when_false can be null
+             **/
+            static obj<AExpression,DIfElseExpr> make(obj<AAllocator> mm,
+                                                     obj<AExpression> test,
+                                                     obj<AExpression> when_true,
+                                                     obj<AExpression> when_false);
+
+            /** create expression for conditional execution of
+             *  @p when_true or @p when_false, depending on result
+             *  of evaluating expression @p test
+             **/
+            static DIfElseExpr * _make(obj<AAllocator> mm,
+                                       obj<AExpression> test,
+                                       obj<AExpression> when_true,
+                                       obj<AExpression> when_false);
+
+            /** create empty if-else expression using memory from @p mm **/
+            static obj<AExpression,DIfElseExpr> make_empty(obj<AAllocator> mm);
+
+            /** create empty if-else expression using memory from @p mm **/
+            static DIfElseExpr * _make_empty(obj<AAllocator> mm);
+
+            ///@}
+            /** @defgroup scm-ifelseexpr-access-methods **/
+            ///@{
+
+            obj<AExpression> test() const noexcept { return test_; }
+            obj<AExpression> when_true() const noexcept { return when_true_; }
+            obj<AExpression> when_false() const noexcept { return when_false_; }
+
+            void assign_test(obj<AExpression> x) { this->test_ = x; }
+            void assign_when_true(obj<AExpression> x) { this->when_true_ = x; }
+            void assign_when_false(obj<AExpression> x) { this->when_false_ = x; }
+
+            ///@}
+            /** @defgroup scm-ifelseexpr-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::ifexpr; }
+            TypeRef typeref() const noexcept { return typeref_; }
+            TypeDescr valuetype() const noexcept { return typeref_.td(); }
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-ifelseexpr-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+            /** @defgroup scm-ifelseexpr-gcobject-facet **/
+            ///@{
+
+            DIfElseExpr * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+
+#ifdef NOT_YET
+            virtual std::set<std::string> get_free_variables() const override {
+                std::set<std::string> retval = test_->get_free_variables();
+
+                std::set<std::string> free_vars;
+                free_vars = when_true_->get_free_variables();
+                for (const auto & s : free_vars)
+                    retval.insert(s);
+
+                free_vars = when_false_->get_free_variables();
+                for (const auto & s : free_vars)
+                    retval.insert(s);
+
+                return retval;
+            }
+
+            virtual std::size_t visit_preorder(VisitFn visitor_fn) override {
+                std::size_t n = 1;
+
+                visitor_fn(this);
+
+                n += this->test_->visit_preorder(visitor_fn);
+                n += this->when_true_->visit_preorder(visitor_fn);
+                n += this->when_false_->visit_preorder(visitor_fn);
+
+                return n;
+            }
+
+            virtual std::size_t visit_layer(VisitFn visitor_fn) override {
+                std::size_t n = 1;
+
+                visitor_fn(this);
+
+                n += this->test_->visit_layer(visitor_fn);
+                n += this->when_true_->visit_layer(visitor_fn);
+                n += this->when_false_->visit_layer(visitor_fn);
+
+                return n;
+            }
+
+            virtual rp<Expression> xform_layer(TransformFn xform_fn) override {
+                this->test_ = this->test_->xform_layer(xform_fn);
+                this->when_true_ = this->when_true_->xform_layer(xform_fn);
+                this->when_false_= this->when_false_->xform_layer(xform_fn);
+
+                return xform_fn(this);
+            }
+
+            virtual void attach_envs(bp<SymbolTable> p) override {
+                test_->attach_envs(p);
+                when_true_->attach_envs(p);
+                when_false_->attach_envs(p);
+            }
+#endif
+
+#ifdef NOT_USING
+            virtual std::int32_t find_free_vars(std::set<bp<Variable>> * p_set) override {
+                return (test_->find_free_vars(p_set)
+                        + when_true_->find_free_vars(p_set)
+                        + when_false_->find_free_vars(p_set));
+            }
+#endif
+
+#ifdef NOPE
+            virtual void display(std::ostream & os) const override;
+            virtual std::uint32_t pretty_print(const ppindentinfo & ppi) const override;
+#endif
+
+        protected:
+#ifdef NOT_YET
+            /**
+             *  @p ifexpr_type  type for value produced by if-expression.
+             *                  same as both when_true->valuetype() and
+             *                  when_false->valuetype().
+             *  @p test   test-expression;  always execute
+             *  @p when_true  then-branch;  executes only when test succeeds
+             *  @p when_false else-branch;  executes only when test fails
+             **/
+            IfExpr(TypeDescr ifexpr_type,
+                   rp<Expression> test,
+                   rp<Expression> when_true,
+                   rp<Expression> when_false)
+                : Expression(exprtype::ifexpr, ifexpr_type),
+                  test_{std::move(test)},
+                  when_true_{std::move(when_true)},
+                  when_false_{std::move(when_false)} {}
+
+            static TypeDescr check_consistent_valuetype(const rp<Expression> & when_true,
+                                                        const rp<Expression> & when_false);
+
+            /** determine if-expr valuetype **/
+            void establish_valuetype();
+#endif
+
+        private:
+            /** expression value always has type consistent
+             *  with this description
+             **/
+            TypeRef typeref_;
+            /** if:
+             *    (if x y z)
+             *
+             *  executes x;  if true execute y; otherwise execute z
+             **/
+            obj<AExpression> test_;
+            obj<AExpression> when_true_;
+            obj<AExpression> when_false_;
+        }; /*IfExpr*/
+
+#ifdef NOPE
+        inline rp<IfExpr>
+        make_ifexpr(const rp<Expression> & test,
+                    const rp<Expression> & when_true,
+                    const rp<Expression> & when_false)
+        {
+            return IfExpr::make(test, when_true, when_false);
+        }
+
+        class IfExprAccess : public IfExpr {
+        public:
+            static rp<IfExprAccess> make(rp<Expression> test,
+                                         rp<Expression> when_true,
+                                         rp<Expression> when_false);
+            static rp<IfExprAccess> make_empty();
+
+            void assign_test(rp<Expression> x) { test_ = std::move(x); }
+            void assign_when_true(rp<Expression> x);
+            void assign_when_false(rp<Expression> x);
+
+        private:
+            IfExprAccess(TypeDescr ifexpr_type,
+                         rp<Expression> test,
+                         rp<Expression> when_true,
+                         rp<Expression> when_false)
+                : IfExpr(ifexpr_type,
+                         std::move(test),
+                         std::move(when_true),
+                         std::move(when_false)) {}
+        };
+#endif
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DIfElseExpr.hpp */

include/xo/expression2/DLambdaExpr.hpp

@@ -0,0 +1,133 @@
+/** @file DLambdaExpr.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include "DLocalSymtab.hpp"
+#include "DString.hpp"
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/facet/obj.hpp>
+
+namespace xo {
+    namespace scm {
+        /** @class DLambdaExpr
+         *  @brief syntax tree for a function/procedure definition
+         *
+         **/
+        class DLambdaExpr {
+        public:
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+            using ppindentinfo = xo::print::ppindentinfo;
+            using size_type = DLocalSymtab::size_type;
+
+        public:
+
+            /** @defgroup scm-lambdaexpr-ctors **/
+            ///@{
+
+            DLambdaExpr(TypeRef typeref,
+                        const DUniqueString * name,
+                        DLocalSymtab * local_symtab,
+                        obj<AExpression> body);
+
+            /** create instance using memory from @p mm **/
+            static obj<AExpression,DLambdaExpr> make(obj<AAllocator> mm,
+                                                     TypeRef typeref,
+                                                     const DUniqueString * name,
+                                                     DLocalSymtab * local_symtab,
+                                                     obj<AExpression> body);
+
+            /** create instance, using memory from @p mm **/
+            static DLambdaExpr * _make(obj<AAllocator> mm,
+                                       TypeRef typeref,
+                                       const DUniqueString * name,
+                                       DLocalSymtab * local_symtab,
+                                       obj<AExpression> body);
+
+            /** create type description for lambda with arguments described by @p symtab
+             *  and return type @p return_td.
+             *  Load-bearing for DLambdaSsm in xo-reader2/
+             **/
+            static TypeDescr assemble_lambda_td(DLocalSymtab * symtab,
+                                                TypeDescr return_td);
+
+            ///@}
+            /** @defgroup scm-lambdaexpr-methods **/
+            ///@{
+
+            DLocalSymtab * local_symtab() const noexcept { return local_symtab_; }
+            size_type n_args() const noexcept { return local_symtab_->n_vars(); }
+            obj<AExpression> body_expr() const noexcept { return body_expr_; }
+
+            // get_free_variables()
+            // visit_preorder()
+            // visit_layer()
+            // xform_layer()
+            // attach_envs(SymbolTable*)
+
+            ///@}
+            /** @defgroup scm-lambdaexpr-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept;
+            TypeRef typeref() const noexcept;
+            TypeDescr valuetype() const noexcept;
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-lambdaexpr-gcobject-facet **/
+            ///@{
+
+            std::size_t shallow_size() const noexcept;
+            DLambdaExpr * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-lambdaexpr-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** expression value always has type consistent
+             *  with description here
+             **/
+            TypeRef typeref_;
+
+            /** name for this lambda (generated if necessary) **/
+            const DUniqueString * name_ = nullptr;
+
+#ifdef NOT_YET // when enabled, need to visit forward_children()
+            /** e.g.
+             *    i64(f64,string)
+             *  for function of two arguments with types (f64, string) respectively,
+             *  that returns an i64.
+             **/
+            const DUniqueString * type_name_str_ = nullptr;
+#endif
+
+            /** symbol table for lambda arguments **/
+            DLocalSymtab * local_symtab_ = nullptr;;
+
+            /** expression for function body **/
+            obj<AExpression> body_expr_;
+
+            // free_var_set
+            // captured_var_set
+            // layer_var_map
+            // nested_lambda_map
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DLambdaExpr.hpp */

include/xo/expression2/DLocalSymtab.hpp

@@ -0,0 +1,128 @@
+/** @file DLocalSymtab.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Binding.hpp"
+#include "DVariable.hpp"
+#include "DUniqueString.hpp"
+#include <xo/object2/DArray.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+
+namespace xo {
+    namespace scm {
+        /** @class DLocalSymtab
+         *  @brief symbol table for a local stack frame
+         **/
+        struct DLocalSymtab {
+        public:
+            using DArray = xo::scm::DArray;
+            using ppindentinfo = xo::print::ppindentinfo;
+            using AGCObject = xo::mm::AGCObject;
+            using VisitReason = xo::mm::VisitReason;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using AAllocator = xo::mm::AAllocator;
+            /* note: uint16_t would be fine too */
+            using size_type = std::uint32_t;
+
+            struct Slot {
+                Slot() = default;
+                explicit Slot(DVariable * var) : var_{var} {}
+
+                /** variable representing a formal argument.
+                 *  binding will be correct only within the same layer
+                 *  as top-level lambda body
+                 *  (i.e. up to the doorstep of each and every nested lambda)
+                 **/
+                DVariable * var_ = nullptr;
+            };
+
+        public:
+            /** @defgroup scm-lambdaexpr-constructors **/
+            ///@{
+
+            /** empty instance with parent @p p, using arrays @p vars for variables
+             *  and @p types for type definitions.
+             **/
+            DLocalSymtab(DLocalSymtab * p, DArray * nv, DArray * nt);
+
+            /** scaffold empty symtab instance,
+             *  capacity for @p nv vars and @p nt types,
+             *  using memory from allocator @p mm.
+             *  Symtab chains to parent @p p.
+             **/
+            static DLocalSymtab * _make_empty(obj<AAllocator> mm,
+                                              DLocalSymtab * p,
+                                              size_type nv,
+                                              size_type nt);
+
+            ///@}
+            /** @defgroup scm-lambdaexpr-methods **/
+            ///@{
+
+            DLocalSymtab * parent() const noexcept { return parent_; }
+            //size_type capacity() const noexcept { return capacity_; }
+            size_type n_vars() const noexcept { return vars_->size(); }
+            size_type n_types() const noexcept { return types_->size(); }
+
+            DVariable * lookup_var(Binding ix) noexcept;
+
+            /** increase slot size (provided below capacity) to append
+             *  binding for one local variable.  Local variable will be allocated
+             *  from @p mm, named @p name, with type described by @p typeref.
+             **/
+            Binding append_var(obj<AAllocator> mm,
+                               const DUniqueString * name,
+                               TypeRef typeref);
+
+            /** increase slot size (provided below capacity) to append
+             *  binding for one local type.  Local type will be allocated
+             *  from @p mm, named @p name, with type described by @p type.
+             **/
+            void append_type(obj<AAllocator> mm,
+                             const DUniqueString * name,
+                             obj<AType> type);
+
+            ///@}
+            /** @defgroup xo-localsymtab-symboltable-facet symboltable facet**/
+            ///@{
+
+            /** true for global symbol table **/
+            bool is_global_symtab() const noexcept { return false; }
+
+            /** lookup binding for variable @p sym **/
+            Binding lookup_binding(const DUniqueString * sym) const noexcept;
+
+            ///@}
+            /** @defgroup xo-localsymtab-gcobject-facet gcobject facet **/
+            ///@{
+
+            DLocalSymtab * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup xo-localsymtab-printable-facet printable facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** parent symbol table from scoping surrounding this one **/
+            DLocalSymtab * parent_ = nullptr;
+            /** variables owned by (declared in) this symbol table
+             *   vars_[i] is convertible to obj<AGCObject>
+             **/
+            DArray * vars_ = nullptr;
+            /** types owned by (defined in) this symbol table
+             *   types_[i] is convertible to obj<AType>
+             **/
+            DArray * types_ = nullptr;
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DLocalSymtab.hpp */

include/xo/expression2/DSequenceExpr.hpp

@@ -0,0 +1,93 @@
+/** @file DSequenceExpr.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "TypeRef.hpp"
+#include <xo/object2/DArray.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+
+namespace xo {
+    namespace scm {
+
+        /** syntax for a sequence of expressions
+         *   {
+         *      expr(1);
+         *      expr(2);
+         *      ...
+         *      expr(n);
+         *   }
+         **/
+        class DSequenceExpr {
+        public:
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+            using size_type = DArray::size_type;
+            using ppindentinfo = xo::print::ppindentinfo;
+
+        public:
+            DSequenceExpr() ;
+            DSequenceExpr(DArray * xv);
+
+            /** create empty sequence using memory from @p mm **/
+            static obj<AExpression,DSequenceExpr> make_empty(obj<AAllocator> mm);
+
+            /** create empty sequence expression using mmeory from @p mm **/
+            static DSequenceExpr * _make_empty(obj<AAllocator> mm);
+
+            size_type size() const noexcept;
+            obj<AExpression> operator[](std::size_t i) const;
+
+            /** append @p expr to the end of this sequence;
+             *  use memory from @p mm if need to expand storage
+             **/
+            void push_back(obj<AAllocator> mm,
+                           obj<AExpression> expr);
+
+            // get_free_variables();
+            // visit_preorder();
+            // visit_layer();
+            // xform_layer()
+            // attach_envs()
+
+            /** @defgroup scm-ifelseexpr-expression-facets **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::sequence; }
+            TypeRef typeref() const noexcept { return typeref_; }
+            TypeDescr valuetype() const noexcept { return typeref_.td(); }
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-sequenceexpr-printable-facet printable facet methods **/
+            ///@{
+
+            /** pretty-printing driver; combine layout+printing **/
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+            /** @defgroup scm-sequenceexpr-gcobject-facet gcobject facet methods **/
+            ///@{
+
+            DSequenceExpr * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+
+        private:
+            /** expression value always has type consistent with this description
+             **/
+            TypeRef typeref_;
+            /** array of expressions **/
+            DArray * expr_v_ = nullptr;
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DSequenceExpr.hpp */

include/xo/expression2/DTypename.hpp

@@ -0,0 +1,78 @@
+/** @file DTypename.hpp
+ *
+ *  @author Roland Conybeare, Mar 2026
+ **/
+
+#pragma once
+
+#include "DUniqueString.hpp"
+#include <xo/type/Type.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/printable2/Printable.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    namespace scm {
+
+        /** @class DTypename
+         *  @brief Container for a named type
+         *
+         *  Represents the result of syntax like
+         *  1. deftype Foo :: i64;
+         *  2. deftype FooAlias :: Foo;
+         **/
+        class DTypename {
+        public:
+            using ppindentinfo = xo::print::ppindentinfo;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AGCObject = xo::mm::AGCObject;
+            using AAllocator = xo::mm::AAllocator;
+
+        public:
+            DTypename(const DUniqueString * name,
+                      obj<AType> type);
+
+            /** create instance
+             *  @p mm      memory allocator
+             *  @p name    type name
+             *  @p type    type definition
+             **/
+            static DTypename * _make(obj<AAllocator> mm,
+                                     const DUniqueString * name,
+                                     obj<AType> type);
+            /** create fop for new instance **/
+            static obj<AGCObject,DTypename> make(obj<AAllocator> mm,
+                                                 const DUniqueString * name,
+                                                 obj<AType> type);
+
+            const DUniqueString * name() const noexcept { return name_; }
+            obj<AType> type() const noexcept { return type_; }
+
+            void assign_name(const DUniqueString * name) { this->name_ = name; }
+
+
+            /** @defgroup scm-typename-gcobject-facet **/
+            ///@{
+
+            DTypename * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-typename-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** symbol name **/
+            const DUniqueString * name_ = nullptr;
+            /** type defintion.  Everything but the name **/
+            obj<AType> type_;
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DTypename.hpp */

include/xo/expression2/DVarRef.hpp

@@ -0,0 +1,85 @@
+/** @file DVarRef.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "Variable.hpp"
+#include <xo/alloc2/GCObjectVisitor.hpp>
+
+namespace xo {
+    namespace scm {
+
+        /** @class DVarRef
+         *  @brief syntax for a variable reference
+         *
+         *  Reference to a known variable possibly
+         *  defined in another scope.
+         *  For non-local non-global variables,
+         **/
+        class DVarRef {
+        public:
+            using ppindentinfo = xo::print::ppindentinfo;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+
+        public:
+            DVarRef(DVariable * vardef,
+                    Binding path);
+
+            /** create instance
+             *  @p mm      memory allocator
+             *  @p vardef  variable definition (name, typeref, binding)
+             *  @p link    number of lexical scope boundaries we must cross
+             *             to reach scope containing @p vardef.
+             *             Only relevant for non-global vardef
+             **/
+            static DVarRef * make(obj<AAllocator> mm,
+                                  DVariable * vardef,
+                                  int32_t link);
+
+            const DUniqueString * name() const;
+            Binding path() const { return path_; }
+
+            /** @defgroup scm-variable-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::varref; }
+            TypeRef typeref() const noexcept;
+            TypeDescr valuetype() const noexcept;
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-variable-gcobject-facet **/
+            ///@{
+
+            DVarRef * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-variable-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** variable definition. Created in the sccope where variable introduced.
+             *  Has an associated @ref Binding, but that binding is only correct
+             *  around any nested scopes.
+             **/
+            DVariable * vardef_ = nullptr;
+
+            /** at runtime: navigate environemnt via this path to get
+             *  runtime memory location for this variable
+             **/
+            Binding path_;
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DVarRef.hpp */

include/xo/expression2/DVariable.hpp

@@ -0,0 +1,93 @@
+/** @file DVariable.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include "DUniqueString.hpp"
+#include "Binding.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/reflect/TypeDescr.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    namespace scm {
+
+        /** @class DVariable
+         *  @brief syntax for a variable reference
+         **/
+        class DVariable {
+        public:
+            using ppindentinfo = xo::print::ppindentinfo;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using AAllocator = xo::mm::AAllocator;
+            using TypeDescr = xo::reflect::TypeDescr;
+
+        public:
+            /** create instance
+             *  @p mm      memory allocator
+             *  @p name    variable name
+             *  @p typeref type information for legal values
+             *             (possibly just placeholder when relying on inference)
+             *  @p path    binding path to runtime value.
+             *             This may be computed after parsing;
+             *             mnust be resolved before execution.
+             **/
+            static DVariable * make(obj<AAllocator> mm,
+                                    const DUniqueString * name,
+                                    const TypeRef & typeref,
+                                    Binding path = Binding());
+
+            DVariable(const DUniqueString * name,
+                      const TypeRef & typeref,
+                      Binding path);
+
+            const DUniqueString * name() const { return name_; }
+            Binding path() const { return path_; }
+
+            void assign_name(const DUniqueString * name) { this->name_ = name; }
+            void assign_path(Binding b) { this->path_ = b; }
+
+            /** @defgroup scm-variable-expression-facet **/
+            ///@{
+
+            exprtype extype() const noexcept { return exprtype::variable; }
+            TypeRef typeref() const noexcept { return typeref_; }
+            TypeDescr valuetype() const noexcept { return typeref_.td(); };
+            void assign_valuetype(TypeDescr td) noexcept;
+
+            ///@}
+            /** @defgroup scm-variable-gcobject-facet **/
+            ///@{
+
+            DVariable * gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept;
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+            ///@}
+            /** @defgroup scm-variable-printable-facet **/
+            ///@{
+
+            bool pretty(const ppindentinfo & ppii) const;
+
+            ///@}
+
+        private:
+            /** symbol name **/
+            const DUniqueString * name_ = nullptr;
+            /** variable value always has type consistent
+             *  with this description
+             **/
+            TypeRef typeref_;
+            /** at runtime: navigate environemnt via this path to get
+             *  runtime memory location for this variable
+             **/
+            Binding path_;
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DVariable.hpp */

include/xo/expression2/DefineExpr.hpp

@@ -0,0 +1,13 @@
+/** @file DefineExpr.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DDefineExpr.hpp"
+#include "detail/IExpression_DDefineExpr.hpp"
+#include "define/IGCObject_DDefineExpr.hpp"
+#include "detail/IPrintable_DDefineExpr.hpp"
+
+/* end DefineExpr.hpp */

include/xo/expression2/Expression.hpp

@@ -0,0 +1,22 @@
+/** @file Expression.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/Expression.json5]
+ *  2. jinja2 template for facet .hpp file:
+ *       [facet.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/Expression.json5]
+ **/
+
+#pragma once
+
+#include "detail/AExpression.hpp"
+#include "detail/IExpression_Any.hpp"
+#include "detail/IExpression_Xfer.hpp"
+#include "detail/RExpression.hpp"
+
+
+/* end Expression.hpp */

include/xo/expression2/GlobalSymtab.hpp

@@ -0,0 +1,13 @@
+/** @file GlobalSymtab.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DGlobalSymtab.hpp"
+#include "symtab/ISymbolTable_DGlobalSymtab.hpp"
+#include "symtab/IGCObject_DGlobalSymtab.hpp"
+#include "symtab/IPrintable_DGlobalSymtab.hpp"
+
+/* end GlobalSymtab.hpp */

include/xo/expression2/IfElseExpr.hpp

@@ -0,0 +1,13 @@
+/** @file IfElseExpr.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DIfElseExpr.hpp"
+#include "detail/IExpression_DIfElseExpr.hpp"
+#include "detail/IGCObject_DIfElseExpr.hpp"
+#include "detail/IPrintable_DIfElseExpr.hpp"
+
+/* end IfElseExpr.hpp */

include/xo/expression2/LambdaExpr.hpp

@@ -0,0 +1,13 @@
+/** @file LambdaExpr.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DLambdaExpr.hpp"
+#include "detail/IExpression_DLambdaExpr.hpp"
+#include "detail/IGCObject_DLambdaExpr.hpp"
+#include "detail/IPrintable_DLambdaExpr.hpp"
+
+/* end LambdaExpr.hpp */

include/xo/expression2/LocalSymtab.hpp

@@ -0,0 +1,13 @@
+/** @file LocalSymtab.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DLocalSymtab.hpp"
+#include "symtab/ISymbolTable_DLocalSymtab.hpp"
+#include "symtab/IGCObject_DLocalSymtab.hpp"
+#include "symtab/IPrintable_DLocalSymtab.hpp"
+
+/* end LocalSymtab.hpp */

include/xo/expression2/SequenceExpr.hpp

@@ -0,0 +1,14 @@
+/** @file SequenceExpr.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DSequenceExpr.hpp"
+#include "detail/IExpression_DSequenceExpr.hpp"
+#include "detail/IGCObject_DSequenceExpr.hpp"
+#include "detail/IPrintable_DSequenceExpr.hpp"
+
+/* end SequenceExpr.hpp */
+

include/xo/expression2/SetupExpression2.hpp

@@ -0,0 +1,25 @@
+/** @file SetupExpression2.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include <xo/alloc2/Collector.hpp>
+
+namespace xo {
+    namespace scm {
+        class SetupExpression2 {
+        public:
+            using ACollector = xo::mm::ACollector;
+
+        public:
+            /** Register expression2 (facet,impl) combinations with FacetRegistry **/
+            static bool register_facets();
+            /** Register expression2 (facet,impl) combinations with FacetRegistry **/
+            static bool register_types(obj<ACollector> gc);
+        };
+    }
+}
+
+/* end SetupExpression2.hpp */

include/xo/expression2/SymbolTable.hpp

@@ -0,0 +1,22 @@
+/** @file SymbolTable.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/SymbolTable.json5]
+ *  2. jinja2 template for facet .hpp file:
+ *       [facet.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/SymbolTable.json5]
+ **/
+
+#pragma once
+
+#include "symtab/ASymbolTable.hpp"
+#include "symtab/ISymbolTable_Any.hpp"
+#include "symtab/ISymbolTable_Xfer.hpp"
+#include "symtab/RSymbolTable.hpp"
+
+
+/* end SymbolTable.hpp */

include/xo/expression2/TypeRef.hpp

@@ -0,0 +1,111 @@
+/** @file TypeRef.hpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include <xo/type/Type.hpp>
+#include <xo/reflect/TypeDescr.hpp>
+#include <xo/alloc2/Collector.hpp>
+#include <xo/alloc2/GCObjectVisitor.hpp>
+#include <xo/flatstring/flatstring.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    namespace scm {
+        /** @class TypeRef
+         *  @brief name and (when established) resolution for type
+         *  associated with an expression
+         *
+         *  Type inference / unification operates on
+         *  @ref xo::scm::TypeBlueprint instances.  See also!
+         **/
+        class TypeRef {
+        public:
+            using TypeDescr = xo::reflect::TypeDescr;
+            using type_var = flatstring<20>;
+            using prefix_type = flatstring<8>;
+            using AGCObjectVisitor = xo::mm::AGCObjectVisitor;
+            using VisitReason = xo::mm::VisitReason;
+            using ppindentinfo = xo::print::ppindentinfo;
+
+        public:
+            TypeRef() = default;
+            TypeRef(const type_var & id, obj<AType> type);
+
+            /** trivial typeref, where already resolved.
+             *  Require: @p td non-null
+             **/
+            static TypeRef resolved(TypeDescr td);
+
+            /** trivial typeref, where already resolved **/
+            static TypeRef resolved(obj<AType> type);
+
+            /** if @p type is non-null
+             *   -> type already resolved
+             *  else
+             *   -> generate unique typevar name, starting with @p prefix
+             **/
+            static TypeRef dwim(prefix_type prefix, obj<AType> type);
+
+            /** if @p td is non-null
+             *   -> type is already resolved
+             *
+             *  if type is not determined (i.e. @p td is nullptr):
+             *   -> generate and store type variable name.
+             **/
+            static TypeRef dwim(prefix_type prefix, TypeDescr td);
+
+            /** generate a unique type-variable name,
+             *  that begins with @p prefix
+             **/
+            static type_var generate_unique(prefix_type prefix);
+
+            const type_var & id() const noexcept { return id_; }
+            TypeDescr td() const noexcept { return td_; }
+
+            /** true iff type at this location has been resolved **/
+            bool is_resolved() const noexcept;
+
+            /** resolve TypeRef by supplying final type-description **/
+            void resolve(TypeDescr td) noexcept { td_ = td; }
+
+            /** pretty-printer support **/
+            bool pretty(const ppindentinfo & ppii) const;
+
+            /** gc support **/
+            void visit_gco_children(VisitReason reason, obj<AGCObjectVisitor> gc) noexcept;
+
+        private:
+            TypeRef(const type_var & id, TypeDescr td);
+
+        private:
+            /** unique (probably generated) name for type at this location **/
+            type_var id_;
+
+            /** Type, when resolved **/
+            obj<AType> type_;
+
+            /** Description for concrete type, once resolved.
+             *  May be null when this TypeRef created,
+             *  but expected to be immutable once established.
+             **/
+            TypeDescr td_ = nullptr;
+        };
+    } /*namespace scm*/
+
+    namespace print {
+        /** pretty printer in <xo/indentlog/print/pretty.hpp> relies on this specialization
+         *  to handle TypeRef instances
+         **/
+        template <>
+        struct ppdetail<xo::scm::TypeRef> {
+            static inline bool print_pretty(const ppindentinfo & ppii, const xo::scm::TypeRef x) {
+                return x.pretty(ppii);
+            }
+        };
+    }
+} /*namespace xo*/
+
+/* end TypeRef.hpp */

include/xo/expression2/Typename.hpp

@@ -0,0 +1,12 @@
+/** @file Typename.hpp
+ *
+ *  @author Roland Conybeare, Mar 2026
+ **/
+
+#pragma once
+
+#include "DTypename.hpp"
+#include "typename/IGCObject_DTypename.hpp"
+#include "typename/IPrintable_DTypename.hpp"
+
+/* end Typename.hpp */

include/xo/expression2/VarRef.hpp

@@ -0,0 +1,13 @@
+/** @file VarRef.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DVarRef.hpp"
+#include "detail/IExpression_DVarRef.hpp"
+#include "detail/IGCObject_DVarRef.hpp"
+#include "detail/IPrintable_DVarRef.hpp"
+
+/* end VarRef.hpp */

include/xo/expression2/Variable.hpp

@@ -0,0 +1,13 @@
+/** @file Variable.hpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#pragma once
+
+#include "DVariable.hpp"
+#include "variable/IExpression_DVariable.hpp"
+#include "variable/IGCObject_DVariable.hpp"
+#include "variable/IPrintable_DVariable.hpp"
+
+/* end Variable.hpp */

include/xo/expression2/define/IGCObject_DDefineExpr.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DDefineExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DDefineExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DDefineExpr.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DDefineExpr.hpp"
+
+namespace xo { namespace scm { class IGCObject_DDefineExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DDefineExpr>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DDefineExpr,
+               xo::scm::IGCObject_DDefineExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DDefineExpr
+         **/
+        class IGCObject_DDefineExpr {
+        public:
+            /** @defgroup scm-gcobject-ddefineexpr-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-ddefineexpr-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DDefineExpr & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DDefineExpr & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/AExpression.hpp

@@ -0,0 +1,89 @@
+/** @file AExpression.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/Expression.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [abstract_facet.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/Expression.json5]
+ **/
+
+#pragma once
+
+// includes (via {facet_includes})
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/reflect/TypeDescr.hpp>
+#include <xo/facet/obj.hpp>
+#include <xo/facet/facet_implementation.hpp>
+#include <xo/facet/typeseq.hpp>
+
+// {pretext} here
+
+namespace xo {
+namespace scm {
+
+using Copaque = const void *;
+using Opaque = void *;
+
+/**
+Representation for executable Schematika expressions
+**/
+class AExpression {
+public:
+    /** @defgroup scm-expression-type-traits **/
+    ///@{
+    // types
+    /** integer identifying a type **/
+    using typeseq = xo::facet::typeseq;
+    using Copaque = const void *;
+    using Opaque = void *;
+    /** struct describing a type **/
+    using TypeDescr = xo::reflect::TypeDescr;
+    ///@}
+
+    /** @defgroup scm-expression-methods **/
+    ///@{
+    // const methods
+    /** An uninitialized AExpression instance will have zero vtable pointer (per {linux,osx} abi).
+     *  Use case for this is narrow. We go to some lengths to avoid null vtable pointers. For example
+     *  obj<AFacet> will have non-null vtable (via IFacet_Any) with all methods terminating.
+     **/
+    bool _has_null_vptr() const noexcept { return *reinterpret_cast<const void * const *>(this) == nullptr; }
+    /** RTTI: unique id# for actual runtime data representation **/
+    virtual typeseq _typeseq() const noexcept = 0;
+    /** destroy instance @p d; calls c++ dtor only for actual runtime type; does not recover memory **/
+    virtual void _drop(Opaque d) const noexcept = 0;
+    /** expression type (constant | apply | ..) **/
+    virtual exprtype extype(Copaque data)  const  noexcept = 0;
+    /** placeholder for type giving possible values for this expression **/
+    virtual TypeRef typeref(Copaque data)  const  noexcept = 0;
+    /** type giving possible values for this expression. Maybe null before typecheck **/
+    virtual TypeDescr valuetype(Copaque data)  const  noexcept = 0;
+
+    // nonconst methods
+    /** assing to valuetype member. Useful when scaffolding expressions **/
+    virtual void assign_valuetype(Opaque data, TypeDescr td)  noexcept = 0;
+    ///@}
+}; /*AExpression*/
+
+/** Implementation IExpression_DRepr of AExpression for state DRepr
+ *  should provide a specialization:
+ *
+ *    template <>
+ *    struct xo::facet::FacetImplementation<AExpression, DRepr> {
+ *        using Impltype = IExpression_DRepr;
+ *    };
+ *
+ *  then IExpression_ImplType<DRepr> --> IExpression_DRepr
+ **/
+template <typename DRepr>
+using IExpression_ImplType = xo::facet::FacetImplType<AExpression, DRepr>;
+
+} /*namespace scm*/
+} /*namespace xo*/
+
+/* AExpression.hpp */

include/xo/expression2/detail/IExpression_Any.hpp

@@ -0,0 +1,92 @@
+/** @file IExpression_Any.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/Expression.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/Expression.json5]
+ **/
+
+#pragma once
+
+#include "AExpression.hpp"
+#include <xo/facet/obj.hpp>
+
+namespace xo { namespace scm { class IExpression_Any; } }
+
+namespace xo {
+namespace facet {
+
+template <>
+struct FacetImplementation<xo::scm::AExpression,
+                           DVariantPlaceholder>
+{
+    using ImplType = xo::scm::IExpression_Any;
+};
+
+}
+}
+
+namespace xo {
+namespace scm {
+
+    /** @class IExpression_Any
+     *  @brief AExpression implementation for empty variant instance
+     **/
+    class IExpression_Any : public AExpression {
+    public:
+        /** @defgroup scm-expression-any-type-traits **/
+        ///@{
+
+        /** integer identifying a type **/
+        using typeseq = xo::facet::typeseq;
+        using TypeDescr = AExpression::TypeDescr;
+
+        ///@}
+        /** @defgroup scm-expression-any-methods **/
+        ///@{
+
+        const AExpression * iface() const { return std::launder(this); }
+
+        // from AExpression
+
+        // builtin methods
+        typeseq _typeseq() const noexcept override { return s_typeseq; }
+        [[noreturn]] void _drop(Opaque) const noexcept override { _fatal(); }
+
+        // const methods
+        [[noreturn]] exprtype extype(Copaque)  const  noexcept override { _fatal(); }
+        [[noreturn]] TypeRef typeref(Copaque)  const  noexcept override { _fatal(); }
+        [[noreturn]] TypeDescr valuetype(Copaque)  const  noexcept override { _fatal(); }
+
+        // nonconst methods
+        [[noreturn]] void assign_valuetype(Opaque, TypeDescr)  noexcept override;
+
+        ///@}
+
+    private:
+        /** @defgraoup scm-expression-any-private-methods **/
+        ///@{
+
+        [[noreturn]] static void _fatal();
+
+        ///@}
+
+    public:
+        /** @defgroup scm-expression-any-member-vars **/
+        ///@{
+
+        static typeseq s_typeseq;
+        static bool _valid;
+
+        ///@}
+    };
+
+} /*namespace scm */
+} /*namespace xo */
+
+/* IExpression_Any.hpp */

include/xo/expression2/detail/IExpression_DApplyExpr.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DApplyExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DApplyExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DApplyExpr.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DApplyExpr.hpp"
+
+namespace xo { namespace scm { class IExpression_DApplyExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DApplyExpr>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DApplyExpr,
+               xo::scm::IExpression_DApplyExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DApplyExpr
+         **/
+        class IExpression_DApplyExpr {
+        public:
+            /** @defgroup scm-expression-dapplyexpr-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-dapplyexpr-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DApplyExpr & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DApplyExpr & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DApplyExpr & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DApplyExpr & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DConstant.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DConstant.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DConstant.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DConstant.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DConstant.hpp"
+
+namespace xo { namespace scm { class IExpression_DConstant; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DConstant>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DConstant,
+               xo::scm::IExpression_DConstant>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DConstant
+         **/
+        class IExpression_DConstant {
+        public:
+            /** @defgroup scm-expression-dconstant-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-dconstant-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DConstant & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DConstant & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DConstant & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DConstant & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DDefineExpr.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DDefineExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DDefineExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DDefineExpr.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DDefineExpr.hpp"
+
+namespace xo { namespace scm { class IExpression_DDefineExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DDefineExpr>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DDefineExpr,
+               xo::scm::IExpression_DDefineExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DDefineExpr
+         **/
+        class IExpression_DDefineExpr {
+        public:
+            /** @defgroup scm-expression-ddefineexpr-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-ddefineexpr-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DDefineExpr & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DDefineExpr & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DDefineExpr & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DDefineExpr & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DIfElseExpr.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DIfElseExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DIfElseExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DIfElseExpr.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DIfElseExpr.hpp"
+
+namespace xo { namespace scm { class IExpression_DIfElseExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DIfElseExpr>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DIfElseExpr,
+               xo::scm::IExpression_DIfElseExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DIfElseExpr
+         **/
+        class IExpression_DIfElseExpr {
+        public:
+            /** @defgroup scm-expression-difelseexpr-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-difelseexpr-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DIfElseExpr & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DIfElseExpr & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DIfElseExpr & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DIfElseExpr & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DLambdaExpr.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DLambdaExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DLambdaExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DLambdaExpr.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DLambdaExpr.hpp"
+
+namespace xo { namespace scm { class IExpression_DLambdaExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DLambdaExpr>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DLambdaExpr,
+               xo::scm::IExpression_DLambdaExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DLambdaExpr
+         **/
+        class IExpression_DLambdaExpr {
+        public:
+            /** @defgroup scm-expression-dlambdaexpr-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-dlambdaexpr-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DLambdaExpr & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DLambdaExpr & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DLambdaExpr & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DLambdaExpr & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DSequenceExpr.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DSequenceExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DSequenceExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DSequenceExpr.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DSequenceExpr.hpp"
+
+namespace xo { namespace scm { class IExpression_DSequenceExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DSequenceExpr>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DSequenceExpr,
+               xo::scm::IExpression_DSequenceExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DSequenceExpr
+         **/
+        class IExpression_DSequenceExpr {
+        public:
+            /** @defgroup scm-expression-dsequenceexpr-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-dsequenceexpr-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DSequenceExpr & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DSequenceExpr & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DSequenceExpr & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DSequenceExpr & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_DVarRef.hpp

@@ -0,0 +1,66 @@
+/** @file IExpression_DVarRef.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IExpression_DVarRef.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IExpression_DVarRef.json5]
+ **/
+
+#pragma once
+
+#include "Expression.hpp"
+#include "Expression.hpp"
+#include "DVarRef.hpp"
+
+namespace xo { namespace scm { class IExpression_DVarRef; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::scm::AExpression,
+                                   xo::scm::DVarRef>
+        {
+            using ImplType = xo::scm::IExpression_Xfer
+              <xo::scm::DVarRef,
+               xo::scm::IExpression_DVarRef>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IExpression_DVarRef
+         **/
+        class IExpression_DVarRef {
+        public:
+            /** @defgroup scm-expression-dvarref-type-traits **/
+            ///@{
+            using TypeDescr = xo::scm::AExpression::TypeDescr;
+            using Copaque = xo::scm::AExpression::Copaque;
+            using Opaque = xo::scm::AExpression::Opaque;
+            ///@}
+            /** @defgroup scm-expression-dvarref-methods **/
+            ///@{
+            // const methods
+            /** expression type (constant | apply | ..) **/
+            static exprtype extype(const DVarRef & self) noexcept;
+            /** placeholder for type giving possible values for this expression **/
+            static TypeRef typeref(const DVarRef & self) noexcept;
+            /** type giving possible values for this expression. Maybe null before typecheck **/
+            static TypeDescr valuetype(const DVarRef & self) noexcept;
+
+            // non-const methods
+            /** assing to valuetype member. Useful when scaffolding expressions **/
+            static void assign_valuetype(DVarRef & self, TypeDescr td) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IExpression_Xfer.hpp

@@ -0,0 +1,103 @@
+/** @file IExpression_Xfer.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/Expression.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/Expression.json5]
+ *
+ *  variables:
+ *    {facet_hpp_fname} -> Expression.hpp
+ *    {impl_hpp_subdir} -> detail
+ *    {facet_ns1} -> xo
+ *    {facet_detail_subdir} -> detail
+ *    {abstract_facet_fname} -> AExpression.hpp
+ **/
+
+#pragma once
+
+#include "AExpression.hpp"
+#include "TypeRef.hpp"
+#include "exprtype.hpp"
+#include <xo/reflect/TypeDescr.hpp>
+
+namespace xo {
+namespace scm {
+    /** @class IExpression_Xfer
+     **/
+    template <typename DRepr, typename IExpression_DRepr>
+    class IExpression_Xfer : public AExpression {
+    public:
+        /** @defgroup scm-expression-xfer-type-traits **/
+        ///@{
+        /** actual implementation (not generated; often delegates to DRepr) **/
+        using Impl = IExpression_DRepr;
+        /** integer identifying a type **/
+        using typeseq = AExpression::typeseq;
+        using TypeDescr = AExpression::TypeDescr;
+        ///@}
+
+        /** @defgroup scm-expression-xfer-methods **/
+        ///@{
+
+        static const DRepr & _dcast(Copaque d) { return *(const DRepr *)d; }
+        static DRepr & _dcast(Opaque d) { return *(DRepr *)d; }
+
+        // from AExpression
+
+        // builtin methods
+        typeseq _typeseq() const noexcept override { return s_typeseq; }
+        void _drop(Opaque d) const noexcept override { _dcast(d).~DRepr(); }
+
+        // const methods
+        exprtype extype(Copaque data)  const  noexcept override {
+            return I::extype(_dcast(data));
+        }
+        TypeRef typeref(Copaque data)  const  noexcept override {
+            return I::typeref(_dcast(data));
+        }
+        TypeDescr valuetype(Copaque data)  const  noexcept override {
+            return I::valuetype(_dcast(data));
+        }
+
+        // non-const methods
+        void assign_valuetype(Opaque data, TypeDescr td)  noexcept override {
+            return I::assign_valuetype(_dcast(data), td);
+        }
+
+        ///@}
+
+    private:
+        using I = Impl;
+
+    public:
+        /** @defgroup scm-expression-xfer-member-vars **/
+        ///@{
+
+        /** typeseq for template parameter DRepr **/
+        static typeseq s_typeseq;
+        /** true iff satisfies facet implementation **/
+        static bool _valid;
+
+        ///@}
+    };
+
+    template <typename DRepr, typename IExpression_DRepr>
+    xo::facet::typeseq
+    IExpression_Xfer<DRepr, IExpression_DRepr>::s_typeseq
+      = xo::facet::typeseq::id<DRepr>();
+
+    template <typename DRepr, typename IExpression_DRepr>
+    bool
+    IExpression_Xfer<DRepr, IExpression_DRepr>::_valid
+      = xo::facet::valid_facet_implementation<AExpression,
+                                              IExpression_Xfer>();
+
+} /*namespace scm */
+} /*namespace xo*/
+
+/* end IExpression_Xfer.hpp */

include/xo/expression2/detail/IGCObject_DApplyExpr.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DApplyExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DApplyExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DApplyExpr.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DApplyExpr.hpp"
+
+namespace xo { namespace scm { class IGCObject_DApplyExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DApplyExpr>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DApplyExpr,
+               xo::scm::IGCObject_DApplyExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DApplyExpr
+         **/
+        class IGCObject_DApplyExpr {
+        public:
+            /** @defgroup scm-gcobject-dapplyexpr-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dapplyexpr-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DApplyExpr & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DApplyExpr & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IGCObject_DConstant.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DConstant.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DConstant.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DConstant.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DConstant.hpp"
+
+namespace xo { namespace scm { class IGCObject_DConstant; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DConstant>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DConstant,
+               xo::scm::IGCObject_DConstant>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DConstant
+         **/
+        class IGCObject_DConstant {
+        public:
+            /** @defgroup scm-gcobject-dconstant-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dconstant-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DConstant & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DConstant & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IGCObject_DIfElseExpr.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DIfElseExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DIfElseExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DIfElseExpr.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DIfElseExpr.hpp"
+
+namespace xo { namespace scm { class IGCObject_DIfElseExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DIfElseExpr>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DIfElseExpr,
+               xo::scm::IGCObject_DIfElseExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DIfElseExpr
+         **/
+        class IGCObject_DIfElseExpr {
+        public:
+            /** @defgroup scm-gcobject-difelseexpr-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-difelseexpr-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DIfElseExpr & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DIfElseExpr & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IGCObject_DLambdaExpr.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DLambdaExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DLambdaExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DLambdaExpr.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DLambdaExpr.hpp"
+
+namespace xo { namespace scm { class IGCObject_DLambdaExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DLambdaExpr>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DLambdaExpr,
+               xo::scm::IGCObject_DLambdaExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DLambdaExpr
+         **/
+        class IGCObject_DLambdaExpr {
+        public:
+            /** @defgroup scm-gcobject-dlambdaexpr-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dlambdaexpr-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DLambdaExpr & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DLambdaExpr & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IGCObject_DSequenceExpr.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DSequenceExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DSequenceExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DSequenceExpr.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DSequenceExpr.hpp"
+
+namespace xo { namespace scm { class IGCObject_DSequenceExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DSequenceExpr>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DSequenceExpr,
+               xo::scm::IGCObject_DSequenceExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DSequenceExpr
+         **/
+        class IGCObject_DSequenceExpr {
+        public:
+            /** @defgroup scm-gcobject-dsequenceexpr-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dsequenceexpr-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DSequenceExpr & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DSequenceExpr & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IGCObject_DVarRef.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DVarRef.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DVarRef.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DVarRef.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DVarRef.hpp"
+
+namespace xo { namespace scm { class IGCObject_DVarRef; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DVarRef>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DVarRef,
+               xo::scm::IGCObject_DVarRef>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DVarRef
+         **/
+        class IGCObject_DVarRef {
+        public:
+            /** @defgroup scm-gcobject-dvarref-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dvarref-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DVarRef & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DVarRef & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DApplyExpr.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DApplyExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DApplyExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DApplyExpr.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DApplyExpr.hpp"
+
+namespace xo { namespace scm { class IPrintable_DApplyExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DApplyExpr>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DApplyExpr,
+               xo::scm::IPrintable_DApplyExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DApplyExpr
+         **/
+        class IPrintable_DApplyExpr {
+        public:
+            /** @defgroup scm-printable-dapplyexpr-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dapplyexpr-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DApplyExpr & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DConstant.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DConstant.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DConstant.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DConstant.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DConstant.hpp"
+
+namespace xo { namespace scm { class IPrintable_DConstant; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DConstant>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DConstant,
+               xo::scm::IPrintable_DConstant>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DConstant
+         **/
+        class IPrintable_DConstant {
+        public:
+            /** @defgroup scm-printable-dconstant-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dconstant-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DConstant & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DDefineExpr.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DDefineExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DDefineExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DDefineExpr.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DDefineExpr.hpp"
+
+namespace xo { namespace scm { class IPrintable_DDefineExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DDefineExpr>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DDefineExpr,
+               xo::scm::IPrintable_DDefineExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DDefineExpr
+         **/
+        class IPrintable_DDefineExpr {
+        public:
+            /** @defgroup scm-printable-ddefineexpr-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-ddefineexpr-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DDefineExpr & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DIfElseExpr.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DIfElseExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DIfElseExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DIfElseExpr.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DIfElseExpr.hpp"
+
+namespace xo { namespace scm { class IPrintable_DIfElseExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DIfElseExpr>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DIfElseExpr,
+               xo::scm::IPrintable_DIfElseExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DIfElseExpr
+         **/
+        class IPrintable_DIfElseExpr {
+        public:
+            /** @defgroup scm-printable-difelseexpr-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-difelseexpr-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DIfElseExpr & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DLambdaExpr.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DLambdaExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DLambdaExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DLambdaExpr.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DLambdaExpr.hpp"
+
+namespace xo { namespace scm { class IPrintable_DLambdaExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DLambdaExpr>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DLambdaExpr,
+               xo::scm::IPrintable_DLambdaExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DLambdaExpr
+         **/
+        class IPrintable_DLambdaExpr {
+        public:
+            /** @defgroup scm-printable-dlambdaexpr-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dlambdaexpr-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DLambdaExpr & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DSequenceExpr.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DSequenceExpr.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DSequenceExpr.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DSequenceExpr.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DSequenceExpr.hpp"
+
+namespace xo { namespace scm { class IPrintable_DSequenceExpr; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DSequenceExpr>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DSequenceExpr,
+               xo::scm::IPrintable_DSequenceExpr>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DSequenceExpr
+         **/
+        class IPrintable_DSequenceExpr {
+        public:
+            /** @defgroup scm-printable-dsequenceexpr-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dsequenceexpr-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DSequenceExpr & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/IPrintable_DVarRef.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DVarRef.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DVarRef.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DVarRef.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DVarRef.hpp"
+
+namespace xo { namespace scm { class IPrintable_DVarRef; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DVarRef>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DVarRef,
+               xo::scm::IPrintable_DVarRef>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DVarRef
+         **/
+        class IPrintable_DVarRef {
+        public:
+            /** @defgroup scm-printable-dvarref-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dvarref-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DVarRef & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/detail/RExpression.hpp

@@ -0,0 +1,94 @@
+/** @file RExpression.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/Expression.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/Expression.json5]
+ **/
+
+#pragma once
+
+#include "AExpression.hpp"
+
+namespace xo {
+namespace scm {
+
+/** @class RExpression
+ **/
+template <typename Object>
+class RExpression : public Object {
+private:
+    using O = Object;
+
+public:
+    /** @defgroup scm-expression-router-type-traits **/
+    ///@{
+    using ObjectType = Object;
+    using DataPtr = Object::DataPtr;
+    using typeseq = xo::reflect::typeseq;
+    using TypeDescr = AExpression::TypeDescr;
+    ///@}
+
+    /** @defgroup scm-expression-router-ctors **/
+    ///@{
+    RExpression() {}
+    RExpression(Object::DataPtr data) : Object{std::move(data)} {}
+    RExpression(const AExpression * iface, void * data)
+      requires std::is_same_v<typename Object::DataType, xo::facet::DVariantPlaceholder>
+      : Object(iface, data) {}
+
+    ///@}
+    /** @defgroup scm-expression-router-methods **/
+    ///@{
+
+    // explicit injected content
+
+    // builtin methods
+    typeseq _typeseq() const noexcept { return O::iface()->_typeseq(); }
+    void _drop() const noexcept { O::iface()->_drop(O::data()); }
+
+    // const methods
+    exprtype extype()  const  noexcept {
+        return O::iface()->extype(O::data());
+    }
+    TypeRef typeref()  const  noexcept {
+        return O::iface()->typeref(O::data());
+    }
+    TypeDescr valuetype()  const  noexcept {
+        return O::iface()->valuetype(O::data());
+    }
+
+    // non-const methods (still const in router!)
+    void assign_valuetype(TypeDescr td)  noexcept {
+        return O::iface()->assign_valuetype(O::data(), td);
+    }
+
+    ///@}
+    /** @defgroup scm-expression-member-vars **/
+    ///@{
+
+    static bool _valid;
+
+    ///@}
+};
+
+template <typename Object>
+bool
+RExpression<Object>::_valid = xo::facet::valid_object_router<Object>();
+
+} /*namespace scm*/
+} /*namespace xo*/
+
+namespace xo { namespace facet {
+    template <typename Object>
+    struct RoutingFor<xo::scm::AExpression, Object> {
+        using RoutingType = xo::scm::RExpression<Object>;
+    };
+} }
+
+/* end RExpression.hpp */

include/xo/expression2/expression2_register_types.hpp

@@ -0,0 +1,15 @@
+/** @file expression2_register_types.hpp
+ *
+ *  @author Roland Conybeare, Dec 2025
+ **/
+
+#pragma once
+
+#include <xo/alloc2/Collector.hpp>
+
+namespace xo {
+    namespace scm {
+    }
+}
+
+/* end expression2_register_types.hpp */

include/xo/expression2/exprtype.hpp

@@ -0,0 +1,98 @@
+/** @file exprtype.hpp
+ *
+ *  Author: Roland Conybeare
+ **/
+
+#pragma once
+
+#include <ostream>
+//#include <cstdint>
+
+namespace xo {
+    namespace scm {
+        /** @enum exprtype
+         *  @brief enum to identify subclasses of xo::scm::Expression.
+         *
+         **/
+        enum class exprtype {
+            /** sentinel value **/
+            invalid = -1,
+
+            /** literal constant.  must satisfy both standard_layout_type + trivial **/
+            constant,
+#ifdef NOT_YET
+            /** a literal constant that refers to a linkable named function **/
+            primitive,
+#endif
+            /** variable/function definition **/
+            define,
+#ifdef NOT_YET
+            /** variable assignment **/
+            assign,
+#endif
+            /** function call **/
+            apply,
+
+            /** function definition **/
+            lambda,
+
+            /** variable definition **/
+            variable,
+            /** variabele reference (possibly non-local) **/
+            varref,
+            /** if-then-else **/
+            ifexpr,
+            /** sequence **/
+            sequence,
+#ifdef NOT_YET
+            )            /** type conversion **/
+            convert,
+#endif
+
+            /** not an expression.  comes last, counts entries **/
+            N
+        };
+
+        inline const char *
+        expr2str(exprtype x)
+        {
+            switch(x) {
+            case exprtype::invalid: return "?exprtype";
+            case exprtype::constant: return "constant";
+#ifdef NOT_YET
+            case exprtype::primitive: return "primitive";
+#endif
+            case exprtype::define: return "define";
+#ifdef NOT_YET
+            case exprtype::assign: return "assign";
+#endif
+            case exprtype::apply: return "apply";
+            case exprtype::lambda: return "lambda";
+            case exprtype::variable: return "variable";
+            case exprtype::varref: return "varref";
+            case exprtype::ifexpr: return "if_expr";
+            case exprtype::sequence: return "sequence";
+#ifdef NOT_YET
+            case exprtype::convert: return "convert";
+#endif
+            case exprtype::N: break;
+            //default: break;
+            }
+
+            return "???exprtype???";
+        }
+
+        /** @brief number of built-in expression types,  repr convenient for array sizing **/
+        static constexpr std::size_t n_exprtype = static_cast<std::size_t>(exprtype::N);
+
+        inline std::ostream &
+        operator<<(std::ostream & os,
+                   exprtype x)
+        {
+            os << expr2str(x);
+            return os;
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end exprtype.hpp */

include/xo/expression2/init_expression2.hpp

@@ -0,0 +1,21 @@
+/** @file init_expression2.hpp
+*
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#pragma once
+
+#include <xo/subsys/Subsystem.hpp>
+
+namespace xo {
+    /* tag to represent the xo-expression2/ subsystem within ordered initialization */
+    enum S_expression2_tag {};
+
+    template <>
+    struct InitSubsys<S_expression2_tag> {
+        static void init();
+        static InitEvidence require();
+    };
+} /*namespace xo*/
+
+/* end init_expression2.hpp */

include/xo/expression2/symtab/ASymbolTable.hpp

@@ -0,0 +1,82 @@
+/** @file ASymbolTable.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/SymbolTable.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [abstract_facet.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/SymbolTable.json5]
+ **/
+
+#pragma once
+
+// includes (via {facet_includes})
+#include "Binding.hpp"
+#include "DUniqueString.hpp"
+#include <xo/facet/obj.hpp>
+#include <xo/facet/facet_implementation.hpp>
+#include <xo/facet/typeseq.hpp>
+
+// {pretext} here
+
+namespace xo {
+namespace scm {
+
+using Copaque = const void *;
+using Opaque = void *;
+
+/**
+Map symbols to schematika expressions. Output of schematika parser
+**/
+class ASymbolTable {
+public:
+    /** @defgroup scm-symboltable-type-traits **/
+    ///@{
+    // types
+    /** integer identifying a type **/
+    using typeseq = xo::facet::typeseq;
+    using Copaque = const void *;
+    using Opaque = void *;
+    ///@}
+
+    /** @defgroup scm-symboltable-methods **/
+    ///@{
+    // const methods
+    /** An uninitialized ASymbolTable instance will have zero vtable pointer (per {linux,osx} abi).
+     *  Use case for this is narrow. We go to some lengths to avoid null vtable pointers. For example
+     *  obj<AFacet> will have non-null vtable (via IFacet_Any) with all methods terminating.
+     **/
+    bool _has_null_vptr() const noexcept { return *reinterpret_cast<const void * const *>(this) == nullptr; }
+    /** RTTI: unique id# for actual runtime data representation **/
+    virtual typeseq _typeseq() const noexcept = 0;
+    /** destroy instance @p d; calls c++ dtor only for actual runtime type; does not recover memory **/
+    virtual void _drop(Opaque d) const noexcept = 0;
+    /** true iff this is toplevel (global) symbol table. **/
+    virtual bool is_global_symtab(Copaque data)  const  noexcept = 0;
+    /** report ingredients needed to address variable at runtime. **/
+    virtual Binding lookup_binding(Copaque data, const DUniqueString * sym)  const  noexcept = 0;
+
+    // nonconst methods
+    ///@}
+}; /*ASymbolTable*/
+
+/** Implementation ISymbolTable_DRepr of ASymbolTable for state DRepr
+ *  should provide a specialization:
+ *
+ *    template <>
+ *    struct xo::facet::FacetImplementation<ASymbolTable, DRepr> {
+ *        using Impltype = ISymbolTable_DRepr;
+ *    };
+ *
+ *  then ISymbolTable_ImplType<DRepr> --> ISymbolTable_DRepr
+ **/
+template <typename DRepr>
+using ISymbolTable_ImplType = xo::facet::FacetImplType<ASymbolTable, DRepr>;
+
+} /*namespace scm*/
+} /*namespace xo*/
+
+/* ASymbolTable.hpp */

include/xo/expression2/symtab/IGCObject_DGlobalSymtab.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DGlobalSymtab.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DGlobalSymtab.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DGlobalSymtab.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DGlobalSymtab.hpp"
+
+namespace xo { namespace scm { class IGCObject_DGlobalSymtab; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DGlobalSymtab>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DGlobalSymtab,
+               xo::scm::IGCObject_DGlobalSymtab>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DGlobalSymtab
+         **/
+        class IGCObject_DGlobalSymtab {
+        public:
+            /** @defgroup scm-gcobject-dglobalsymtab-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dglobalsymtab-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DGlobalSymtab & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DGlobalSymtab & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/symtab/IGCObject_DLocalSymtab.hpp

@@ -0,0 +1,69 @@
+/** @file IGCObject_DLocalSymtab.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DLocalSymtab.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DLocalSymtab.json5]
+ **/
+
+#pragma once
+
+#include "GCObject.hpp"
+#include <xo/alloc2/GCObject.hpp>
+#include <xo/alloc2/Allocator.hpp>
+#include "DLocalSymtab.hpp"
+
+namespace xo { namespace scm { class IGCObject_DLocalSymtab; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::mm::AGCObject,
+                                   xo::scm::DLocalSymtab>
+        {
+            using ImplType = xo::mm::IGCObject_Xfer
+              <xo::scm::DLocalSymtab,
+               xo::scm::IGCObject_DLocalSymtab>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IGCObject_DLocalSymtab
+         **/
+        class IGCObject_DLocalSymtab {
+        public:
+            /** @defgroup scm-gcobject-dlocalsymtab-type-traits **/
+            ///@{
+            using size_type = xo::mm::AGCObject::size_type;
+            using AAllocator = xo::mm::AGCObject::AAllocator;
+            using AGCObjectVisitor = xo::mm::AGCObject::AGCObjectVisitor;
+            using VisitReason = xo::mm::AGCObject::VisitReason;
+            using Copaque = xo::mm::AGCObject::Copaque;
+            using Opaque = xo::mm::AGCObject::Opaque;
+            ///@}
+            /** @defgroup scm-gcobject-dlocalsymtab-methods **/
+            ///@{
+            // const methods
+
+            // non-const methods
+            /** move instance using object visitor.
+Arguably abusing the word 'visitor' here **/
+            static Opaque gco_shallow_move(DLocalSymtab & self, obj<AGCObjectVisitor> gc) noexcept;
+            /** Invoke fn.visit_child(iface,data) for each child GCObject pointer.
+Context: provides address of data pointer so it can be updated in place
+when @p fn invokes garbage collector reentry point **/
+            static void visit_gco_children(DLocalSymtab & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept;
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/symtab/IPrintable_DGlobalSymtab.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DGlobalSymtab.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DGlobalSymtab.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DGlobalSymtab.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DGlobalSymtab.hpp"
+
+namespace xo { namespace scm { class IPrintable_DGlobalSymtab; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DGlobalSymtab>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DGlobalSymtab,
+               xo::scm::IPrintable_DGlobalSymtab>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DGlobalSymtab
+         **/
+        class IPrintable_DGlobalSymtab {
+        public:
+            /** @defgroup scm-printable-dglobalsymtab-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dglobalsymtab-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DGlobalSymtab & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */

include/xo/expression2/symtab/IPrintable_DLocalSymtab.hpp

@@ -0,0 +1,62 @@
+/** @file IPrintable_DLocalSymtab.hpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DLocalSymtab.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_repr.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DLocalSymtab.json5]
+ **/
+
+#pragma once
+
+#include "Printable.hpp"
+#include <xo/printable2/Printable.hpp>
+#include <xo/printable2/detail/IPrintable_Xfer.hpp>
+#include "DLocalSymtab.hpp"
+
+namespace xo { namespace scm { class IPrintable_DLocalSymtab; } }
+
+namespace xo {
+    namespace facet {
+        template <>
+        struct FacetImplementation<xo::print::APrintable,
+                                   xo::scm::DLocalSymtab>
+        {
+            using ImplType = xo::print::IPrintable_Xfer
+              <xo::scm::DLocalSymtab,
+               xo::scm::IPrintable_DLocalSymtab>;
+        };
+    }
+}
+
+namespace xo {
+    namespace scm {
+        /** @class IPrintable_DLocalSymtab
+         **/
+        class IPrintable_DLocalSymtab {
+        public:
+            /** @defgroup scm-printable-dlocalsymtab-type-traits **/
+            ///@{
+            using ppindentinfo = xo::print::APrintable::ppindentinfo;
+            using Copaque = xo::print::APrintable::Copaque;
+            using Opaque = xo::print::APrintable::Opaque;
+            ///@}
+            /** @defgroup scm-printable-dlocalsymtab-methods **/
+            ///@{
+            // const methods
+            /** Pretty-printing support for this object.
+See [xo-indentlog/xo/indentlog/pretty.hpp] **/
+            static bool pretty(const DLocalSymtab & self, const ppindentinfo & ppii);
+
+            // non-const methods
+            ///@}
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end */