From 3232b22eecdc62d2a52f285571388aaa5d95ae34 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 00:09:14 +0900
Subject: [PATCH 01/36] Move some `library` class member definitions into .cpp

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |  6 +--
 VERSION                           |  2 +-
 include/meevax/kernel/library.hpp | 75 +++----------------------------
 src/kernel/library.cpp            | 73 +++++++++++++++++++++++++++++-
 4 files changed, 82 insertions(+), 74 deletions(-)

diff --git a/README.md b/README.md
index 340e996ef..8cb5540f2 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.81.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.82.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.81_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.82_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.81
+Meevax Lisp System, version 0.4.82
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 460492218..487f66b64 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.81
+0.4.82
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index b5c9f11dd..c724da75a 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -35,39 +35,11 @@ inline namespace kernel
       declare(*this);
     }
 
-    explicit library(const_reference declarations)
-    {
-      for (let const& declaration : declarations)
-      {
-        declare(declaration);
-      }
-    }
+    explicit library(const_reference);
 
     static auto boot() -> void;
 
-    auto declare(const_reference declaration) -> void
-    {
-      if (declaration.is<pair>() and car(declaration).is<symbol>()
-                                 and car(declaration).as<symbol>().value == "export")
-      {
-        for (let const& export_spec : cdr(declaration))
-        {
-          declare_export(export_spec);
-        }
-      }
-      else if (declaration.is<pair>() and car(declaration).is<symbol>()
-                                      and car(declaration).as<symbol>().value == "begin")
-      {
-        for (let const& command_or_definition : cdr(declaration))
-        {
-          declare(command_or_definition);
-        }
-      }
-      else
-      {
-        evaluate(declaration); // Non-standard extension.
-      }
-    }
+    auto declare(const_reference) -> void;
 
     auto declare_export(const_reference export_spec) -> void
     {
@@ -79,44 +51,7 @@ inline namespace kernel
       declare_export(read(export_spec));
     }
 
-    auto resolve_export_specs()
-    {
-      let bindings = unit;
-
-      for (let const& export_spec : export_specs)
-      {
-        if (export_spec.is<pair>() and car(export_spec).is<symbol>()
-                                   and car(export_spec).as<symbol>().value == "rename")
-        {
-          if (let const& binding = identify(cadr(export_spec), unit); binding.as<identity>().is_free())
-          {
-            std::cout << error(make<string>("exported but undefined"), cadr(export_spec)) << std::endl;
-          }
-          else
-          {
-            bindings = cons(make<absolute>(caddr(export_spec), binding.as<absolute>().load()), bindings);
-          }
-        }
-        else
-        {
-          if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
-          {
-            std::cout << error(make<string>("exported but undefined"), export_spec) << std::endl;
-          }
-          else
-          {
-            bindings = cons(binding, bindings);
-          }
-        }
-      }
-
-      return bindings;
-    }
-
-    friend auto operator <<(std::ostream & os, library const& library) -> std::ostream &
-    {
-      return os << library.global();
-    }
+    auto resolve_export_specs() -> lvalue;
 
     #define DEFINE_BASIS_LIBRARY(NAME)                                         \
     struct NAME##_library_t                                                    \
@@ -151,7 +86,9 @@ inline namespace kernel
     #undef DEFINE_BASIS_LIBRARY
   };
 
-  extern std::map<std::string, library> libraries;
+  auto operator <<(std::ostream &, library const&) -> std::ostream &;
+
+  extern std::unordered_map<std::string, library> libraries;
 
   template <typename... Ts>
   auto define_library(std::string const& name, Ts&&... xs)
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 34ab7485c..3ef71f233 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1144,7 +1144,13 @@ inline namespace kernel
     declare_export("emergency-exit");
   }
 
-  std::map<std::string, library> libraries {};
+  library::library(const_reference declarations)
+  {
+    for (let const& declaration : declarations)
+    {
+      declare(declaration);
+    }
+  }
 
   auto library::boot() -> void
   {
@@ -1241,5 +1247,70 @@ inline namespace kernel
       }
     }
   }
+
+  auto library::declare(const_reference declaration) -> void
+  {
+    if (declaration.is<pair>() and car(declaration).is<symbol>()
+                               and car(declaration).as<symbol>().value == "export")
+    {
+      for (let const& export_spec : cdr(declaration))
+      {
+        declare_export(export_spec);
+      }
+    }
+    else if (declaration.is<pair>() and car(declaration).is<symbol>()
+                                    and car(declaration).as<symbol>().value == "begin")
+    {
+      for (let const& command_or_definition : cdr(declaration))
+      {
+        declare(command_or_definition);
+      }
+    }
+    else
+    {
+      evaluate(declaration); // Non-standard extension.
+    }
+  }
+
+  auto library::resolve_export_specs() -> lvalue
+  {
+    let bindings = unit;
+
+    for (let const& export_spec : export_specs)
+    {
+      if (export_spec.is<pair>() and car(export_spec).is<symbol>()
+                                 and car(export_spec).as<symbol>().value == "rename")
+      {
+        if (let const& binding = identify(cadr(export_spec), unit); binding.as<identity>().is_free())
+        {
+          std::cout << error(make<string>("exported but undefined"), cadr(export_spec)) << std::endl;
+        }
+        else
+        {
+          bindings = cons(make<absolute>(caddr(export_spec), binding.as<absolute>().load()), bindings);
+        }
+      }
+      else
+      {
+        if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
+        {
+          std::cout << error(make<string>("exported but undefined"), export_spec) << std::endl;
+        }
+        else
+        {
+          bindings = cons(binding, bindings);
+        }
+      }
+    }
+
+    return bindings;
+  }
+
+  auto operator <<(std::ostream & os, library const& library) -> std::ostream &
+  {
+    return os << library.global();
+  }
+
+  std::unordered_map<std::string, library> libraries {};
 } // namespace kernel
 } // namespace meevax

From a5795d9203eaa8b44ae8e16215b492b9d1286b9d Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 00:24:46 +0900
Subject: [PATCH 02/36] Rename `library::declare_export` to `export_`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |   6 +-
 VERSION                           |   2 +-
 include/meevax/kernel/library.hpp |  10 +-
 src/kernel/library.cpp            | 380 +++++++++++++++---------------
 4 files changed, 201 insertions(+), 197 deletions(-)

diff --git a/README.md b/README.md
index 8cb5540f2..ea9f1ba38 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.82.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.83.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.82_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.83_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.82
+Meevax Lisp System, version 0.4.83
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 487f66b64..6f7c9a31a 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.82
+0.4.83
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index c724da75a..aa1866b9f 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -41,15 +41,9 @@ inline namespace kernel
 
     auto declare(const_reference) -> void;
 
-    auto declare_export(const_reference export_spec) -> void
-    {
-      export_specs.push_back(export_spec);
-    }
+    auto export_(const_reference) -> void;
 
-    auto declare_export(std::string const& export_spec) -> void
-    {
-      declare_export(read(export_spec));
-    }
+    auto export_(std::string const&) -> void;
 
     auto resolve_export_specs() -> lvalue;
 
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 3ef71f233..c5f511c50 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -37,18 +37,18 @@ inline namespace kernel
     define<syntax>("quote-syntax", quote_syntax);
     define<syntax>("set!", set);
 
-    declare_export("begin");
-    declare_export("call-with-current-continuation!");
-    declare_export("define");
-    declare_export("define-syntax");
-    declare_export("if");
-    declare_export("lambda");
-    declare_export("let-syntax");
-    declare_export("letrec");
-    declare_export("letrec-syntax");
-    declare_export("quote");
-    declare_export("quote-syntax");
-    declare_export("set!");
+    export_("begin");
+    export_("call-with-current-continuation!");
+    export_("define");
+    export_("define-syntax");
+    export_("if");
+    export_("lambda");
+    export_("let-syntax");
+    export_("letrec");
+    export_("letrec-syntax");
+    export_("quote");
+    export_("quote-syntax");
+    export_("set!");
   }
 
   library::library(environment_library_t)
@@ -75,9 +75,9 @@ inline namespace kernel
       return interaction_environment();
     });
 
-    declare_export("environment");
-    declare_export("interaction-environment");
-    declare_export("%load");
+    export_("environment");
+    export_("interaction-environment");
+    export_("%load");
   }
 
   library::library(equivalence_library_t)
@@ -85,8 +85,8 @@ inline namespace kernel
     define<predicate>("eq?",  [](let const& xs) { return eq (car(xs), cadr(xs)); });
     define<predicate>("eqv?", [](let const& xs) { return eqv(car(xs), cadr(xs)); });
 
-    declare_export("eq?");
-    declare_export("eqv?");
+    export_("eq?");
+    export_("eqv?");
   }
 
   library::library(number_library_t)
@@ -181,36 +181,36 @@ inline namespace kernel
       return make<string>(lexical_cast<std::string>(car(xs)));
     });
 
-    declare_export("number?");
-    declare_export("complex?");
-    declare_export("real?");
-    declare_export("rational?");
-    declare_export("integer?");
-    declare_export("exact-integer?");
-    declare_export("%complex?");
-    declare_export("ratio?");
-    declare_export("single-float?");
-    declare_export("double-float?");
-    declare_export("=");
-    declare_export("!=");
-    declare_export("<");
-    declare_export("<=");
-    declare_export(">");
-    declare_export(">=");
-    declare_export("+");
-    declare_export("*");
-    declare_export("-");
-    declare_export("/");
-    declare_export("%");
-    declare_export("floor");
-    declare_export("ceiling");
-    declare_export("truncate");
-    declare_export("round");
-    declare_export("expt");
-    declare_export("exact");
-    declare_export("inexact");
-    declare_export("integer->char");
-    declare_export("number->string");
+    export_("number?");
+    export_("complex?");
+    export_("real?");
+    export_("rational?");
+    export_("integer?");
+    export_("exact-integer?");
+    export_("%complex?");
+    export_("ratio?");
+    export_("single-float?");
+    export_("double-float?");
+    export_("=");
+    export_("!=");
+    export_("<");
+    export_("<=");
+    export_(">");
+    export_(">=");
+    export_("+");
+    export_("*");
+    export_("-");
+    export_("/");
+    export_("%");
+    export_("floor");
+    export_("ceiling");
+    export_("truncate");
+    export_("round");
+    export_("expt");
+    export_("exact");
+    export_("inexact");
+    export_("integer->char");
+    export_("number->string");
   }
 
   library::library(inexact_library_t)
@@ -268,24 +268,24 @@ inline namespace kernel
       }
     });
 
-    declare_export("finite?");
-    declare_export("infinite?");
-    declare_export("nan?");
-    declare_export("exp");
-    declare_export("sqrt");
-    declare_export("log");
-    declare_export("sin");
-    declare_export("asin");
-    declare_export("sinh");
-    declare_export("asinh");
-    declare_export("cos");
-    declare_export("acos");
-    declare_export("cosh");
-    declare_export("acosh");
-    declare_export("tan");
-    declare_export("atan");
-    declare_export("tanh");
-    declare_export("atanh");
+    export_("finite?");
+    export_("infinite?");
+    export_("nan?");
+    export_("exp");
+    export_("sqrt");
+    export_("log");
+    export_("sin");
+    export_("asin");
+    export_("sinh");
+    export_("asinh");
+    export_("cos");
+    export_("acos");
+    export_("cosh");
+    export_("acosh");
+    export_("tan");
+    export_("atan");
+    export_("tanh");
+    export_("atanh");
   }
 
   library::library(pair_library_t)
@@ -337,40 +337,40 @@ inline namespace kernel
     define<procedure>("set-car!", [](auto&& xs) { return caar(xs) = cadr(xs); });
     define<procedure>("set-cdr!", [](auto&& xs) { return cdar(xs) = cadr(xs); });
 
-    declare_export("pair?");
-    declare_export("cons");
-    declare_export("car");
-    declare_export("cdr");
-    declare_export("set-car!");
-    declare_export("set-cdr!");
-    declare_export("caaaar");
-    declare_export("caaadr");
-    declare_export("caaar");
-    declare_export("caadar");
-    declare_export("caaddr");
-    declare_export("caadr");
-    declare_export("caar");
-    declare_export("cadaar");
-    declare_export("cadadr");
-    declare_export("cadar");
-    declare_export("caddar");
-    declare_export("cadddr");
-    declare_export("caddr");
-    declare_export("cadr");
-    declare_export("cdaaar");
-    declare_export("cdaadr");
-    declare_export("cdaar");
-    declare_export("cdadar");
-    declare_export("cdaddr");
-    declare_export("cdadr");
-    declare_export("cdar");
-    declare_export("cddaar");
-    declare_export("cddadr");
-    declare_export("cddar");
-    declare_export("cdddar");
-    declare_export("cddddr");
-    declare_export("cdddr");
-    declare_export("cddr");
+    export_("pair?");
+    export_("cons");
+    export_("car");
+    export_("cdr");
+    export_("set-car!");
+    export_("set-cdr!");
+    export_("caaaar");
+    export_("caaadr");
+    export_("caaar");
+    export_("caadar");
+    export_("caaddr");
+    export_("caadr");
+    export_("caar");
+    export_("cadaar");
+    export_("cadadr");
+    export_("cadar");
+    export_("caddar");
+    export_("cadddr");
+    export_("caddr");
+    export_("cadr");
+    export_("cdaaar");
+    export_("cdaadr");
+    export_("cdaar");
+    export_("cdadar");
+    export_("cdaddr");
+    export_("cdadr");
+    export_("cdar");
+    export_("cddaar");
+    export_("cddadr");
+    export_("cddar");
+    export_("cdddar");
+    export_("cddddr");
+    export_("cdddr");
+    export_("cddr");
   }
 
   library::library(list_library_t)
@@ -402,10 +402,10 @@ inline namespace kernel
       return make<vector>(for_each_in, car(xs));
     });
 
-    declare_export("null?");
-    declare_export("append");
-    declare_export("list->string");
-    declare_export("list->vector");
+    export_("null?");
+    export_("append");
+    export_("list->string");
+    export_("list->vector");
   }
 
   library::library(symbol_library_t)
@@ -420,8 +420,8 @@ inline namespace kernel
       return make<string>(car(xs).as<symbol>());
     });
 
-    declare_export("symbol?");
-    declare_export("symbol->string");
+    export_("symbol?");
+    export_("symbol->string");
   }
 
   library::library(character_library_t)
@@ -455,9 +455,9 @@ inline namespace kernel
       }
     });
 
-    declare_export("char?");
-    declare_export("char->integer");
-    declare_export("char-codepoint");
+    export_("char?");
+    export_("char->integer");
+    export_("char-codepoint");
   }
 
   library::library(string_library_t)
@@ -582,21 +582,21 @@ inline namespace kernel
       return intern(car(xs).as<string>());
     });
 
-    declare_export("string?");
-    declare_export("make-string");
-    declare_export("string-append");
-    declare_export("string-copy");
-    declare_export("string-length");
-    declare_export("string-ref");
-    declare_export("string-set!");
-    declare_export("string=?");
-    declare_export("string<?");
-    declare_export("string<=?");
-    declare_export("string>?");
-    declare_export("string>=?");
-    declare_export("string->list");
-    declare_export("string->number");
-    declare_export("string->symbol");
+    export_("string?");
+    export_("make-string");
+    export_("string-append");
+    export_("string-copy");
+    export_("string-length");
+    export_("string-ref");
+    export_("string-set!");
+    export_("string=?");
+    export_("string<?");
+    export_("string<=?");
+    export_("string>?");
+    export_("string>=?");
+    export_("string->list");
+    export_("string->number");
+    export_("string->symbol");
   }
 
   library::library(vector_library_t)
@@ -700,15 +700,15 @@ inline namespace kernel
       }
     });
 
-    declare_export("vector?");
-    declare_export("vector");
-    declare_export("make-vector");
-    declare_export("vector-length");
-    declare_export("vector-ref");
-    declare_export("vector-set!");
-    declare_export("vector-fill!");
-    declare_export("vector->list");
-    declare_export("vector->string");
+    export_("vector?");
+    export_("vector");
+    export_("make-vector");
+    export_("vector-length");
+    export_("vector-ref");
+    export_("vector-set!");
+    export_("vector-fill!");
+    export_("vector->list");
+    export_("vector->string");
   }
 
   library::library(control_library_t)
@@ -723,8 +723,8 @@ inline namespace kernel
       return car(xs).is<continuation>();
     });
 
-    declare_export("closure?");
-    declare_export("continuation?");
+    export_("closure?");
+    export_("continuation?");
   }
 
   library::library(exception_library_t)
@@ -759,12 +759,12 @@ inline namespace kernel
       return car(xs).is<syntax_error>();
     });
 
-    declare_export("throw");
-    declare_export("make-error");
-    declare_export("error?");
-    declare_export("read-error?");
-    declare_export("file-error?");
-    declare_export("syntax-error?");
+    export_("throw");
+    export_("make-error");
+    export_("error?");
+    export_("read-error?");
+    export_("file-error?");
+    export_("syntax-error?");
   }
 
   library::library(port_library_t)
@@ -953,32 +953,32 @@ inline namespace kernel
       return unspecified_object;
     });
 
-    declare_export("input-port?");
-    declare_export("output-port?");
-    declare_export("binary-port?");
-    declare_export("textual-port?");
-    declare_export("port?");
-    declare_export("input-port-open?");
-    declare_export("output-port-open?");
-    declare_export("standard-input-port");
-    declare_export("standard-output-port");
-    declare_export("standard-error-port");
-    declare_export("open-input-file");
-    declare_export("open-output-file");
-    declare_export("close-input-port");
-    declare_export("close-output-port");
-    declare_export("open-input-string");
-    declare_export("open-output-string");
-    declare_export("get-output-string");
-    declare_export("%read-char");
-    declare_export("%peek-char");
-    declare_export("eof-object?");
-    declare_export("eof-object");
-    declare_export("read-ready?");
-    declare_export("%read-string");
-    declare_export("put-char");
-    declare_export("put-string");
-    declare_export("%flush-output-port");
+    export_("input-port?");
+    export_("output-port?");
+    export_("binary-port?");
+    export_("textual-port?");
+    export_("port?");
+    export_("input-port-open?");
+    export_("output-port-open?");
+    export_("standard-input-port");
+    export_("standard-output-port");
+    export_("standard-error-port");
+    export_("open-input-file");
+    export_("open-output-file");
+    export_("close-input-port");
+    export_("close-output-port");
+    export_("open-input-string");
+    export_("open-output-string");
+    export_("get-output-string");
+    export_("%read-char");
+    export_("%peek-char");
+    export_("eof-object?");
+    export_("eof-object");
+    export_("read-ready?");
+    export_("%read-string");
+    export_("put-char");
+    export_("put-string");
+    export_("%flush-output-port");
   }
 
   library::library(evaluate_library_t)
@@ -988,7 +988,7 @@ inline namespace kernel
       return cadr(xs).as<environment>().evaluate(car(xs));
     });
 
-    declare_export("eval");
+    export_("eval");
   }
 
   library::library(read_library_t)
@@ -1009,7 +1009,7 @@ inline namespace kernel
       }
     });
 
-    declare_export("%read");
+    export_("%read");
   }
 
   library::library(write_library_t)
@@ -1039,8 +1039,8 @@ inline namespace kernel
       return standard_output;
     });
 
-    declare_export("%write-simple");
-    declare_export("print");
+    export_("%write-simple");
+    export_("print");
   }
 
   library::library(macro_library_t)
@@ -1077,11 +1077,11 @@ inline namespace kernel
       return make<syntactic_closure>(car(xs), cadr(xs), caddr(xs));
     });
 
-    declare_export("identifier?");
-    declare_export("identifier->symbol");
-    declare_export("transformer?");
-    declare_export("syntactic-closure?");
-    declare_export("make-syntactic-closure");
+    export_("identifier?");
+    export_("identifier->symbol");
+    export_("transformer?");
+    export_("syntactic-closure?");
+    export_("make-syntactic-closure");
   }
 
   library::library(experimental_library_t)
@@ -1111,9 +1111,9 @@ inline namespace kernel
       return std::numeric_limits<double>::is_iec559;
     });
 
-    declare_export("type-of");
-    declare_export("disassemble");
-    declare_export("ieee-float?");
+    export_("type-of");
+    export_("disassemble");
+    export_("ieee-float?");
   }
 
   library::library(context_library_t)
@@ -1141,7 +1141,7 @@ inline namespace kernel
       }
     });
 
-    declare_export("emergency-exit");
+    export_("emergency-exit");
   }
 
   library::library(const_reference declarations)
@@ -1187,8 +1187,8 @@ inline namespace kernel
         return car(xs).is<procedure>();
       });
 
-      library.declare_export("foreign-function");
-      library.declare_export("foreign-function?");
+      library.export_("foreign-function");
+      library.export_("foreign-function?");
     });
 
     define_library("(meevax garbage-collector)", [](library & library)
@@ -1203,8 +1203,8 @@ inline namespace kernel
         return make<exact_integer>(gc.count());
       });
 
-      library.declare_export("gc-collect");
-      library.declare_export("gc-count");
+      library.export_("gc-collect");
+      library.export_("gc-count");
     });
 
     define_library("(meevax version)", [](library & library)
@@ -1214,7 +1214,7 @@ inline namespace kernel
         return features();
       });
 
-      library.declare_export("features");
+      library.export_("features");
     });
 
     std::vector<string_view> const codes {
@@ -1255,7 +1255,7 @@ inline namespace kernel
     {
       for (let const& export_spec : cdr(declaration))
       {
-        declare_export(export_spec);
+        export_(export_spec);
       }
     }
     else if (declaration.is<pair>() and car(declaration).is<symbol>()
@@ -1272,6 +1272,16 @@ inline namespace kernel
     }
   }
 
+  auto library::export_(const_reference export_spec) -> void
+  {
+    export_specs.push_back(export_spec);
+  }
+
+  auto library::export_(std::string const& export_spec) -> void
+  {
+    export_(read(export_spec));
+  }
+
   auto library::resolve_export_specs() -> lvalue
   {
     let bindings = unit;

From 472be2a026cc4284ef188df0ac4ba5d3381a5350 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 01:05:16 +0900
Subject: [PATCH 03/36] Rename `library::declare_import` to `import_`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +-
 VERSION                               |  2 +-
 include/meevax/kernel/environment.hpp | 17 ++---
 include/meevax/kernel/library.hpp     |  2 +-
 src/kernel/environment.cpp            | 92 ++++++++++++++-------------
 src/kernel/library.cpp                | 10 +--
 src/main.cpp                          |  2 +-
 7 files changed, 63 insertions(+), 68 deletions(-)

diff --git a/README.md b/README.md
index ea9f1ba38..3740a531e 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.83.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.84.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.83_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.84_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.83
+Meevax Lisp System, version 0.4.84
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 6f7c9a31a..1bf629591 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.83
+0.4.84
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 160ad2c46..92cc03f43 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -56,12 +56,6 @@ inline namespace kernel
     explicit environment(Ts&&... xs)
     {
       (import(xs), ...);
-
-      // define<procedure>("set-batch!",       [this](let const& xs, auto&&...) { return batch       = select(car(xs)); });
-      // define<procedure>("set-debug!",       [this](let const& xs, auto&&...) { return debug       = select(car(xs)); });
-      // define<procedure>("set-interactive!", [this](let const& xs, auto&&...) { return interactive = select(car(xs)); });
-      // define<procedure>("set-trace!",       [this](let const& xs, auto&&...) { return trace       = select(car(xs)); });
-      // define<procedure>("set-verbose!",     [this](let const& xs, auto&&...) { return verbose     = select(car(xs)); });
     }
 
     auto operator [](const_reference) -> const_reference;
@@ -70,13 +64,6 @@ inline namespace kernel
 
     auto apply(const_reference, const_reference) -> lvalue;
 
-    auto declare_import(const_reference) -> void;
-
-    auto declare_import(std::string const& import_set) -> void
-    {
-      declare_import(read(import_set));
-    }
-
     auto define(const_reference, const_reference = undefined) -> void;
 
     auto define(symbol::value_type const&, const_reference = undefined) -> void;
@@ -109,6 +96,10 @@ inline namespace kernel
 
     auto global() const noexcept -> const_reference;
 
+    auto import_(const_reference) -> void;
+
+    auto import_(std::string const&) -> void;
+
     auto load(std::string const&) -> lvalue;
 
     auto scope() const noexcept -> const_reference;
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index aa1866b9f..b6ed7b76f 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -39,7 +39,7 @@ inline namespace kernel
 
     static auto boot() -> void;
 
-    auto declare(const_reference) -> void;
+    auto evaluate(const_reference) -> void;
 
     auto export_(const_reference) -> void;
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 60b22e459..695fcb8d8 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -51,49 +51,6 @@ inline namespace kernel
     return result;
   }
 
-  auto resolve_import_set(const_reference import_set) -> lvalue
-  {
-    if (car(import_set).as<symbol>().value == "only")
-    {
-      let const exported_bindings = resolve_import_set(cadr(import_set));
-
-      let filtered_bindings = unit;
-
-      for (let const& identifier : cddr(import_set))
-      {
-        if (let const& binding = assq(identifier, exported_bindings); select(binding))
-        {
-          filtered_bindings = cons(binding, filtered_bindings);
-        }
-        else
-        {
-          throw error(make<string>("no such identifier"), identifier);
-        }
-      }
-
-      return filtered_bindings;
-    }
-    else if (auto iter = libraries.find(lexical_cast<std::string>(import_set)); iter != std::end(libraries))
-    {
-      return std::get<1>(*iter).resolve_export_specs();
-    }
-    else
-    {
-      throw error(make<string>("no such library"), import_set);
-    }
-  }
-
-  auto environment::declare_import(const_reference import_set) -> void
-  {
-    let const bindings = resolve_import_set(import_set);
-
-    for (let const& binding : bindings)
-    {
-      define(binding.as<absolute>().symbol(),
-             binding.as<absolute>().load());
-    }
-  }
-
   auto environment::define(const_reference name, const_reference value) -> void
   {
     assert(name.is_also<identifier>());
@@ -119,7 +76,7 @@ inline namespace kernel
     {
       for (let const& import_set : cdr(expression))
       {
-        declare_import(import_set);
+        import_(import_set);
       }
 
       return unspecified_object;
@@ -172,6 +129,53 @@ inline namespace kernel
     return second;
   }
 
+  auto resolve_import_set(const_reference import_set) -> lvalue
+  {
+    if (car(import_set).as<symbol>().value == "only")
+    {
+      let const exported_bindings = resolve_import_set(cadr(import_set));
+
+      let filtered_bindings = unit;
+
+      for (let const& identifier : cddr(import_set))
+      {
+        if (let const& binding = assq(identifier, exported_bindings); select(binding))
+        {
+          filtered_bindings = cons(binding, filtered_bindings);
+        }
+        else
+        {
+          throw error(make<string>("no such identifier"), identifier);
+        }
+      }
+
+      return filtered_bindings;
+    }
+    else if (auto iter = libraries.find(lexical_cast<std::string>(import_set)); iter != std::end(libraries))
+    {
+      return std::get<1>(*iter).resolve_export_specs();
+    }
+    else
+    {
+      throw error(make<string>("no such library"), import_set);
+    }
+  }
+
+  auto environment::import_(const_reference import_set) -> void
+  {
+    let const bindings = resolve_import_set(import_set);
+
+    for (let const& binding : bindings)
+    {
+      define(binding.as<absolute>().symbol(), binding.as<absolute>().load());
+    }
+  }
+
+  auto environment::import_(std::string const& import_set) -> void
+  {
+    import_(read(import_set));
+  }
+
   auto environment::load(std::string const& s) -> lvalue
   {
     if (let port = make<input_file_port>(s); port and port.as<input_file_port>().is_open())
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index c5f511c50..01d0baabc 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -59,7 +59,7 @@ inline namespace kernel
 
       for (let const& x : xs)
       {
-        e.as<environment>().declare_import(x);
+        e.as<environment>().import_(x);
       }
 
       return e;
@@ -1148,7 +1148,7 @@ inline namespace kernel
   {
     for (let const& declaration : declarations)
     {
-      declare(declaration);
+      evaluate(declaration);
     }
   }
 
@@ -1248,7 +1248,7 @@ inline namespace kernel
     }
   }
 
-  auto library::declare(const_reference declaration) -> void
+  auto library::evaluate(const_reference declaration) -> void
   {
     if (declaration.is<pair>() and car(declaration).is<symbol>()
                                and car(declaration).as<symbol>().value == "export")
@@ -1263,12 +1263,12 @@ inline namespace kernel
     {
       for (let const& command_or_definition : cdr(declaration))
       {
-        declare(command_or_definition);
+        evaluate(command_or_definition);
       }
     }
     else
     {
-      evaluate(declaration); // Non-standard extension.
+      environment::evaluate(declaration); // Non-standard extension.
     }
   }
 
diff --git a/src/main.cpp b/src/main.cpp
index 0aca95e72..3cdd734dd 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -33,7 +33,7 @@ auto main(int const argc, char const* const* const argv) -> int
     if (main.interactive)
     {
       main.display_version();
-      main.declare_import("(scheme r5rs)");
+      main.import_("(scheme r5rs)");
     }
 
     while (main.interactive and main.char_ready())

From 25dfbef3d10c2f83bbd8225348eaa0b78b32192c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 01:52:21 +0900
Subject: [PATCH 04/36] Rename typename `lvalue` to `value_type`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                                |  6 ++--
 VERSION                                  |  2 +-
 include/meevax/kernel/complex.hpp        | 14 ++++----
 include/meevax/kernel/configurator.hpp   |  8 ++---
 include/meevax/kernel/constant.hpp       |  2 +-
 include/meevax/kernel/environment.hpp    | 16 ++++-----
 include/meevax/kernel/exact_integer.hpp  | 20 +++++------
 include/meevax/kernel/floating_point.hpp | 28 +++++++--------
 include/meevax/kernel/identity.hpp       | 16 ++++-----
 include/meevax/kernel/iterator.hpp       |  8 ++---
 include/meevax/kernel/library.hpp        |  4 +--
 include/meevax/kernel/list.hpp           | 22 ++++++------
 include/meevax/kernel/machine.hpp        |  8 ++---
 include/meevax/kernel/number.hpp         | 22 ++++++------
 include/meevax/kernel/object.hpp         |  4 +--
 include/meevax/kernel/optimizer.hpp      |  2 +-
 include/meevax/kernel/overview.hpp       | 26 +++++++-------
 include/meevax/kernel/pair.hpp           |  6 ++--
 include/meevax/kernel/procedure.hpp      |  2 +-
 include/meevax/kernel/ratio.hpp          | 20 +++++------
 include/meevax/kernel/reader.hpp         | 14 ++++----
 include/meevax/kernel/string.hpp         |  4 +--
 include/meevax/kernel/syntax.hpp         |  2 +-
 include/meevax/kernel/vector.hpp         |  5 ++-
 src/kernel/constant.cpp                  |  2 +-
 src/kernel/environment.cpp               | 16 ++++-----
 src/kernel/exact_integer.cpp             | 10 +++---
 src/kernel/identity.cpp                  | 12 +++----
 src/kernel/library.cpp                   | 14 ++++----
 src/kernel/list.cpp                      | 12 +++----
 src/kernel/number.cpp                    | 44 ++++++++++++------------
 src/kernel/ratio.cpp                     | 10 +++---
 src/kernel/string.cpp                    |  4 +--
 33 files changed, 191 insertions(+), 194 deletions(-)

diff --git a/README.md b/README.md
index 3740a531e..028c6ab0a 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.84.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.85.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.84_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.85_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.84
+Meevax Lisp System, version 0.4.85
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 1bf629591..aab4c6e65 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.84
+0.4.85
diff --git a/include/meevax/kernel/complex.hpp b/include/meevax/kernel/complex.hpp
index 59f173cfb..c75d3cd81 100644
--- a/include/meevax/kernel/complex.hpp
+++ b/include/meevax/kernel/complex.hpp
@@ -38,7 +38,7 @@ inline namespace kernel
     auto imag() noexcept -> reference;
 
     #define DEFINE(NAME)                                                       \
-    auto NAME() const -> lvalue override                                       \
+    auto NAME() const -> value_type override                                   \
     {                                                                          \
       return unspecified_object;                                               \
     }                                                                          \
@@ -55,7 +55,7 @@ inline namespace kernel
     #undef DEFINE
 
     #define DEFINE(NAME)                                                       \
-    auto NAME(const_reference) const -> lvalue override                        \
+    auto NAME(const_reference) const -> value_type override                    \
     {                                                                          \
       return unspecified_object;                                               \
     }                                                                          \
@@ -66,11 +66,11 @@ inline namespace kernel
 
     #undef DEFINE
 
-    auto operator + (const_reference) const -> lvalue override { return unspecified_object; }
-    auto operator - (const_reference) const -> lvalue override { return unspecified_object; }
-    auto operator * (const_reference) const -> lvalue override { return unspecified_object; }
-    auto operator / (const_reference) const -> lvalue override { return unspecified_object; }
-    auto operator % (const_reference) const -> lvalue override { return unspecified_object; }
+    auto operator + (const_reference) const -> value_type override { return unspecified_object; }
+    auto operator - (const_reference) const -> value_type override { return unspecified_object; }
+    auto operator * (const_reference) const -> value_type override { return unspecified_object; }
+    auto operator / (const_reference) const -> value_type override { return unspecified_object; }
+    auto operator % (const_reference) const -> value_type override { return unspecified_object; }
 
     auto operator ==(const_reference) const -> bool override { return false; };
     auto operator !=(const_reference) const -> bool override { return false; };
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index 6d58d3de6..705c4ca7a 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -90,7 +90,7 @@ inline namespace kernel
         return make<bool>(debug = true);
       }),
 
-      std::make_pair('h', [](auto&&...) -> lvalue
+      std::make_pair('h', [](auto&&...) -> value_type
       {
         configurator::display_help();
         throw exit_status::success;
@@ -101,7 +101,7 @@ inline namespace kernel
         return make<bool>(interactive = true);
       }),
 
-      std::make_pair('v', [](auto&&...) -> lvalue
+      std::make_pair('v', [](auto&&...) -> value_type
       {
         configurator::display_version();
         throw exit_status::success;
@@ -140,7 +140,7 @@ inline namespace kernel
         return make<bool>(debug = true);
       }),
 
-      std::make_pair("help", [](auto&&...) -> lvalue
+      std::make_pair("help", [](auto&&...) -> value_type
       {
         display_help();
         throw exit_status::success;
@@ -161,7 +161,7 @@ inline namespace kernel
         return make<bool>(verbose = true);
       }),
 
-      std::make_pair("version", [](auto&&...) -> lvalue
+      std::make_pair("version", [](auto&&...) -> value_type
       {
         display_version();
         throw exit_status::success;
diff --git a/include/meevax/kernel/constant.hpp b/include/meevax/kernel/constant.hpp
index 120aeafb3..dfdd9a564 100644
--- a/include/meevax/kernel/constant.hpp
+++ b/include/meevax/kernel/constant.hpp
@@ -23,7 +23,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  extern std::unordered_map<std::string, lvalue> const constants;
+  extern std::unordered_map<std::string, value_type> const constants;
 } // namespace kernel
 } // namespace meevax
 
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 92cc03f43..8fff4a5d4 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -62,7 +62,7 @@ inline namespace kernel
 
     auto operator [](std::string const&) -> const_reference;
 
-    auto apply(const_reference, const_reference) -> lvalue;
+    auto apply(const_reference, const_reference) -> value_type;
 
     auto define(const_reference, const_reference = undefined) -> void;
 
@@ -74,13 +74,13 @@ inline namespace kernel
       define(name, make<T>(name, std::forward<decltype(xs)>(xs)...));
     }
 
-    auto evaluate(const_reference) -> lvalue;
+    auto evaluate(const_reference) -> value_type;
 
-    auto execute() -> lvalue;
+    auto execute() -> value_type;
 
-    auto execute(const_reference) -> lvalue;
+    auto execute(const_reference) -> value_type;
 
-    auto fork() const -> lvalue
+    auto fork() const -> value_type
     {
       return make<environment>(*this);
     }
@@ -100,15 +100,15 @@ inline namespace kernel
 
     auto import_(std::string const&) -> void;
 
-    auto load(std::string const&) -> lvalue;
+    auto load(std::string const&) -> value_type;
 
     auto scope() const noexcept -> const_reference;
 
     auto scope() noexcept -> reference;
 
-    auto identify(const_reference, const_reference) -> lvalue;
+    auto identify(const_reference, const_reference) -> value_type;
 
-    auto identify(const_reference, const_reference) const -> lvalue;
+    auto identify(const_reference, const_reference) const -> value_type;
   };
 
   auto operator >>(std::istream &, environment &) -> std::istream &;
diff --git a/include/meevax/kernel/exact_integer.hpp b/include/meevax/kernel/exact_integer.hpp
index bf50a8313..f11e5f387 100644
--- a/include/meevax/kernel/exact_integer.hpp
+++ b/include/meevax/kernel/exact_integer.hpp
@@ -28,13 +28,11 @@ inline namespace kernel
 {
   struct exact_integer : public number
   {
-    using value_type = mpz_t;
-
-    value_type value;
+    mpz_t value;
 
     explicit exact_integer() noexcept;
 
-    explicit exact_integer(value_type) noexcept;
+    explicit exact_integer(mpz_t) noexcept;
 
     exact_integer(exact_integer const&) noexcept;
 
@@ -85,7 +83,7 @@ inline namespace kernel
 
     auto truncate_quotient(exact_integer const&) const -> exact_integer;
 
-    #define DEFINE(NAME) auto NAME() const -> lvalue override
+    #define DEFINE(NAME) auto NAME() const -> value_type override
 
     DEFINE(exact); DEFINE(inexact);
 
@@ -97,7 +95,7 @@ inline namespace kernel
 
     #undef DEFINE
 
-    #define DEFINE(NAME) auto NAME(const_reference) const -> lvalue override
+    #define DEFINE(NAME) auto NAME(const_reference) const -> value_type override
 
     DEFINE(atan2);
     DEFINE(pow);
@@ -118,11 +116,11 @@ inline namespace kernel
 
     explicit operator std::string() const;
 
-    auto operator + (const_reference) const -> lvalue override;
-    auto operator - (const_reference) const -> lvalue override;
-    auto operator * (const_reference) const -> lvalue override;
-    auto operator / (const_reference) const -> lvalue override;
-    auto operator % (const_reference) const -> lvalue override;
+    auto operator + (const_reference) const -> value_type override;
+    auto operator - (const_reference) const -> value_type override;
+    auto operator * (const_reference) const -> value_type override;
+    auto operator / (const_reference) const -> value_type override;
+    auto operator % (const_reference) const -> value_type override;
 
     auto operator ==(const_reference) const -> bool override;
     auto operator !=(const_reference) const -> bool override;
diff --git a/include/meevax/kernel/floating_point.hpp b/include/meevax/kernel/floating_point.hpp
index c9b8a6364..da2dda972 100644
--- a/include/meevax/kernel/floating_point.hpp
+++ b/include/meevax/kernel/floating_point.hpp
@@ -31,23 +31,21 @@ inline namespace kernel
   struct floating_point : public number
                         , public std::numeric_limits<T>
   {
-    using value_type = T;
-
-    value_type value;
+    T value;
 
     explicit constexpr floating_point(T value = {})
       : value { value }
     {}
 
     explicit floating_point(std::string const& token) try
-      : value { lexical_cast<value_type>(token) }
+      : value { lexical_cast<T>(token) }
     {}
     catch (...)
     {
       throw read_error(make<string>("not a decimal"), make<string>(token));
     }
 
-    auto exact() const -> lvalue override
+    auto exact() const -> value_type override
     {
       /* ---- R7RS 6.2.6 (exact z) ---------------------------------------------
        *
@@ -103,13 +101,13 @@ inline namespace kernel
       return lexical_cast<std::string>(value);
     }
 
-    auto inexact() const -> lvalue override
+    auto inexact() const -> value_type override
     {
       return make(floating_point<double>(value));
     }
 
     #define DEFINE(NAME)                                                       \
-    auto NAME() const -> lvalue override                                       \
+    auto NAME() const -> value_type override                                   \
     {                                                                          \
       return make(floating_point(std::NAME(value)));                           \
     }                                                                          \
@@ -127,7 +125,7 @@ inline namespace kernel
     #undef DEFINE
 
     #define DEFINE(NAME)                                                       \
-    auto NAME(const_reference x) const -> lvalue override                      \
+    auto NAME(const_reference x) const -> value_type override                  \
     {                                                                          \
       return make(floating_point(std::NAME(value, x.as<number>().inexact().as<double_float>()))); \
     }                                                                          \
@@ -138,14 +136,14 @@ inline namespace kernel
 
     #undef DEFINE
 
-    constexpr operator value_type() const noexcept { return value; }
-    constexpr operator value_type()       noexcept { return value; }
+    constexpr operator T() const noexcept { return value; }
+    constexpr operator T()       noexcept { return value; }
 
-    auto operator + (const_reference) const -> lvalue override;
-    auto operator - (const_reference) const -> lvalue override;
-    auto operator * (const_reference) const -> lvalue override;
-    auto operator / (const_reference) const -> lvalue override;
-    auto operator % (const_reference) const -> lvalue override;
+    auto operator + (const_reference) const -> value_type override;
+    auto operator - (const_reference) const -> value_type override;
+    auto operator * (const_reference) const -> value_type override;
+    auto operator / (const_reference) const -> value_type override;
+    auto operator % (const_reference) const -> value_type override;
 
     auto operator ==(const_reference) const -> bool override;
     auto operator !=(const_reference) const -> bool override;
diff --git a/include/meevax/kernel/identity.hpp b/include/meevax/kernel/identity.hpp
index c970475f6..de71a0570 100644
--- a/include/meevax/kernel/identity.hpp
+++ b/include/meevax/kernel/identity.hpp
@@ -36,9 +36,9 @@ inline namespace kernel
 
     virtual auto load(const_reference) const -> const_reference = 0;
 
-    virtual auto make_load_mnemonic() const -> lvalue = 0;
+    virtual auto make_load_mnemonic() const -> value_type = 0;
 
-    virtual auto make_store_mnemonic() const -> lvalue = 0;
+    virtual auto make_store_mnemonic() const -> value_type = 0;
 
     virtual auto symbol() const -> const_reference;
   };
@@ -57,9 +57,9 @@ inline namespace kernel
 
     auto load(const_reference = unit) const -> const_reference override;
 
-    auto make_load_mnemonic() const -> lvalue override;
+    auto make_load_mnemonic() const -> value_type override;
 
-    auto make_store_mnemonic() const -> lvalue override;
+    auto make_store_mnemonic() const -> value_type override;
   };
 
   struct keyword : public absolute
@@ -77,9 +77,9 @@ inline namespace kernel
 
     auto load(const_reference) const -> const_reference override;
 
-    auto make_load_mnemonic() const -> lvalue override;
+    auto make_load_mnemonic() const -> value_type override;
 
-    auto make_store_mnemonic() const -> lvalue override;
+    auto make_store_mnemonic() const -> value_type override;
   };
 
   auto operator ==(relative const&, relative const&) -> bool;
@@ -90,9 +90,9 @@ inline namespace kernel
 
     auto load(const_reference e) const -> const_reference override;
 
-    auto make_load_mnemonic() const -> lvalue override;
+    auto make_load_mnemonic() const -> value_type override;
 
-    auto make_store_mnemonic() const -> lvalue override;
+    auto make_store_mnemonic() const -> value_type override;
   };
 } // namespace kernel
 } // namespace meevax
diff --git a/include/meevax/kernel/iterator.hpp b/include/meevax/kernel/iterator.hpp
index 10c884cb1..2f845eb46 100644
--- a/include/meevax/kernel/iterator.hpp
+++ b/include/meevax/kernel/iterator.hpp
@@ -25,24 +25,24 @@ namespace meevax
 {
 inline namespace kernel
 {
-  struct iterator : public std::reference_wrapper<const lvalue>
+  struct iterator : public std::reference_wrapper<const value_type>
   {
     using iterator_category = std::forward_iterator_tag;
 
-    using value_type = lvalue;
+    using value_type = meevax::value_type;
 
     using reference = meevax::reference;
 
     using const_reference = meevax::const_reference;
 
-    using pointer = typename std::add_pointer<lvalue>::type;
+    using pointer = typename std::add_pointer<value_type>::type;
 
     using difference_type = std::ptrdiff_t;
 
     using size_type = std::size_t;
 
     iterator(const_reference x)
-      : std::reference_wrapper<const lvalue> { std::cref(x) }
+      : std::reference_wrapper<const value_type> { std::cref(x) }
     {}
 
     auto operator *() const -> const_reference;
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index b6ed7b76f..0c5026d25 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -27,7 +27,7 @@ inline namespace kernel
 {
   struct library : public environment
   {
-    std::vector<lvalue> export_specs;
+    std::vector<value_type> export_specs;
 
     template <typename F, REQUIRES(std::is_invocable<F, library &>)>
     explicit library(F&& declare)
@@ -45,7 +45,7 @@ inline namespace kernel
 
     auto export_(std::string const&) -> void;
 
-    auto resolve_export_specs() -> lvalue;
+    auto resolve_export_specs() -> value_type;
 
     #define DEFINE_BASIS_LIBRARY(NAME)                                         \
     struct NAME##_library_t                                                    \
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index fc2a6405b..0b490e73b 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -36,7 +36,7 @@ inline namespace kernel
     {
       return x.get().template as<pair>();
     }
-    else if constexpr (std::is_same<type, lvalue>::value)
+    else if constexpr (std::is_same<type, value_type>::value)
     {
       return x.template as<pair>();
     }
@@ -56,8 +56,8 @@ inline namespace kernel
     return std::get<1>(unwrap(std::forward<decltype(x)>(x)));
   };
 
-  template <typename T, typename U, REQUIRES(std::is_convertible<T, lvalue>,
-                                             std::is_convertible<U, lvalue>)>
+  template <typename T, typename U, REQUIRES(std::is_convertible<T, value_type>,
+                                             std::is_convertible<U, value_type>)>
   auto operator |(T&& x, U&& y) -> decltype(auto)
   {
     return make<pair>(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
@@ -104,7 +104,7 @@ inline namespace kernel
 
   auto list_copy = [](auto const& x)
   {
-    auto copy = [](auto&& rec, const_reference x) -> lvalue
+    auto copy = [](auto&& rec, const_reference x) -> value_type
     {
       if (x.is<pair>())
       {
@@ -178,25 +178,25 @@ inline namespace kernel
     return car(list_tail(std::forward<decltype(xs)>(xs)...));
   };
 
-  auto take(const_reference, std::size_t) -> lvalue;
+  auto take(const_reference, std::size_t) -> value_type;
 
   auto length = [](auto const& x) constexpr
   {
     return std::distance(std::cbegin(x), std::cend(x));
   };
 
-  auto append2(const_reference, const_reference) -> lvalue;
+  auto append2(const_reference, const_reference) -> value_type;
 
-  auto reverse(const_reference) -> lvalue;
+  auto reverse(const_reference) -> value_type;
 
-  auto zip(const_reference, const_reference) -> lvalue;
+  auto zip(const_reference, const_reference) -> value_type;
 
-  auto unzip1(const_reference xs) -> lvalue;
+  auto unzip1(const_reference xs) -> value_type;
 
-  auto unzip2(const_reference xs) -> std::tuple<lvalue, lvalue>;
+  auto unzip2(const_reference xs) -> std::tuple<value_type, value_type>;
 
   template <typename Function>
-  auto map(Function&& function, const_reference x) -> lvalue
+  auto map(Function&& function, const_reference x) -> value_type
   {
     return x.is<null>() ? unit : cons(function(car(x)), map(function, cdr(x)));
   }
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index afddfdad7..5bc119eb3 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -118,7 +118,7 @@ inline namespace kernel
         , identity { syntactic_environment.as<environment>().identify(expression, syntactic_environment.as<environment>().scope()) }
       {}
 
-      auto identify_with_offset(const_reference use_env_scope) -> lvalue
+      auto identify_with_offset(const_reference use_env_scope) -> value_type
       {
         if (identity.is<relative>())
         {
@@ -188,7 +188,7 @@ inline namespace kernel
       environment &   current_environment,
       const_reference current_expression,
       const_reference current_scope = unit,
-      const_reference current_continuation = list(make(mnemonic::stop))) -> lvalue
+      const_reference current_continuation = list(make(mnemonic::stop))) -> value_type
     {
       if (current_expression.is<null>()) /* ------------------------------------
       *
@@ -328,7 +328,7 @@ inline namespace kernel
     }
 
     template <auto trace = false>
-    inline auto execute() -> lvalue
+    inline auto execute() -> value_type
     {
     decode:
       if constexpr (trace)
@@ -693,7 +693,7 @@ inline namespace kernel
       }
     }
 
-    static auto identify(const_reference variable, const_reference scope) -> lvalue
+    static auto identify(const_reference variable, const_reference scope) -> value_type
     {
       for (auto outer = std::begin(scope); outer != std::end(scope); ++outer)
       {
diff --git a/include/meevax/kernel/number.hpp b/include/meevax/kernel/number.hpp
index 93ecec62d..eea218cd5 100644
--- a/include/meevax/kernel/number.hpp
+++ b/include/meevax/kernel/number.hpp
@@ -187,17 +187,17 @@ inline namespace kernel
   template <typename T> auto operator > (ratio const& a, floating_point<T> const& b) -> bool { return a.inexact().as<double_float>() >  b; }
   template <typename T> auto operator >=(ratio const& a, floating_point<T> const& b) -> bool { return a.inexact().as<double_float>() >= b; }
 
-  template <typename T> auto floating_point<T>::operator * (const_reference x) const -> lvalue { return apply(mul, *this, x); }
-  template <typename T> auto floating_point<T>::operator + (const_reference x) const -> lvalue { return apply(add, *this, x); }
-  template <typename T> auto floating_point<T>::operator - (const_reference x) const -> lvalue { return apply(sub, *this, x); }
-  template <typename T> auto floating_point<T>::operator / (const_reference x) const -> lvalue { return apply(div, *this, x); }
-  template <typename T> auto floating_point<T>::operator % (const_reference x) const -> lvalue { return apply(mod, *this, x); }
-  template <typename T> auto floating_point<T>::operator !=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, x); }
-  template <typename T> auto floating_point<T>::operator < (const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, x); }
-  template <typename T> auto floating_point<T>::operator <=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, x); }
-  template <typename T> auto floating_point<T>::operator ==(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, x); }
-  template <typename T> auto floating_point<T>::operator > (const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, x); }
-  template <typename T> auto floating_point<T>::operator >=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator * (const_reference x) const -> value_type { return apply(mul, *this, x); }
+  template <typename T> auto floating_point<T>::operator + (const_reference x) const -> value_type { return apply(add, *this, x); }
+  template <typename T> auto floating_point<T>::operator - (const_reference x) const -> value_type { return apply(sub, *this, x); }
+  template <typename T> auto floating_point<T>::operator / (const_reference x) const -> value_type { return apply(div, *this, x); }
+  template <typename T> auto floating_point<T>::operator % (const_reference x) const -> value_type { return apply(mod, *this, x); }
+  template <typename T> auto floating_point<T>::operator !=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator < (const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator <=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator ==(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator > (const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, x); }
+  template <typename T> auto floating_point<T>::operator >=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, x); }
 
   template <typename T> auto operator * (floating_point<T> const& a, exact_integer const& b)         { return a *  b.inexact().as<double_float>(); }
   template <typename T> auto operator + (floating_point<T> const& a, exact_integer const& b)         { return a +  b.inexact().as<double_float>(); }
diff --git a/include/meevax/kernel/object.hpp b/include/meevax/kernel/object.hpp
index 958698de4..3d4ca3d72 100644
--- a/include/meevax/kernel/object.hpp
+++ b/include/meevax/kernel/object.hpp
@@ -52,13 +52,13 @@ inline namespace kernel
   template <typename T, typename... Ts>
   auto make(Ts&&... xs)
   {
-    return lvalue::allocate<T>(std::forward<decltype(xs)>(xs)...); // NOTE: This leaks memory if exception thrown from T's constructor.
+    return value_type::allocate<T>(std::forward<decltype(xs)>(xs)...); // NOTE: This leaks memory if exception thrown from T's constructor.
   }
 
   template <typename T>
   auto make(T&& x)
   {
-    return lvalue::allocate<typename std::decay<T>::type>(std::forward<decltype(x)>(x));
+    return value_type::allocate<typename std::decay<T>::type>(std::forward<decltype(x)>(x));
   }
 } // namespace kernel
 } // namespace meevax
diff --git a/include/meevax/kernel/optimizer.hpp b/include/meevax/kernel/optimizer.hpp
index f10466acb..e8211f12d 100644
--- a/include/meevax/kernel/optimizer.hpp
+++ b/include/meevax/kernel/optimizer.hpp
@@ -27,7 +27,7 @@ inline namespace kernel
   {
     static inline auto fmerge_constants = true;
 
-    static auto merge_constants(const_reference c) -> lvalue
+    static auto merge_constants(const_reference c) -> value_type
     {
       if (not c.is<pair>())
       {
diff --git a/include/meevax/kernel/overview.hpp b/include/meevax/kernel/overview.hpp
index 3d3ad6c3c..c96fb0f37 100644
--- a/include/meevax/kernel/overview.hpp
+++ b/include/meevax/kernel/overview.hpp
@@ -44,17 +44,19 @@ inline namespace kernel
   template <template <typename...> typename, typename, typename...>
   class heterogeneous;
 
-  using lvalue = heterogeneous<gc_pointer, pair, bool, std::int32_t, std::uint32_t, float, mnemonic>;
+  using value_type = heterogeneous<gc_pointer, pair, bool, std::int32_t, std::uint32_t, float, mnemonic>;
 
-  using                   let = lvalue;
-  using       reference = let &;
-  using const_reference = let const&;
+  using reference = value_type &;
+
+  using const_reference = value_type const&;
+
+  using let = value_type;
 
   using null = std::nullptr_t;
 
   struct number
   {
-    #define DEFINE(NAME) virtual auto NAME() const -> lvalue = 0
+    #define DEFINE(NAME) virtual auto NAME() const -> value_type = 0
 
     DEFINE(exact); DEFINE(inexact);
 
@@ -66,8 +68,8 @@ inline namespace kernel
 
     #undef DEFINE
 
-    virtual auto atan2(const_reference) const -> lvalue = 0;
-    virtual auto pow  (const_reference) const -> lvalue = 0;
+    virtual auto atan2(const_reference) const -> value_type = 0;
+    virtual auto pow  (const_reference) const -> value_type = 0;
 
     virtual auto is_complex () const -> bool { return true ; }
     virtual auto is_real    () const -> bool { return false; }
@@ -78,11 +80,11 @@ inline namespace kernel
     virtual auto is_infinite() const -> bool { return false; }
     virtual auto is_nan     () const -> bool { return false; }
 
-    virtual auto operator + (const_reference) const -> lvalue = 0;
-    virtual auto operator - (const_reference) const -> lvalue = 0;
-    virtual auto operator * (const_reference) const -> lvalue = 0;
-    virtual auto operator / (const_reference) const -> lvalue = 0;
-    virtual auto operator % (const_reference) const -> lvalue = 0;
+    virtual auto operator + (const_reference) const -> value_type = 0;
+    virtual auto operator - (const_reference) const -> value_type = 0;
+    virtual auto operator * (const_reference) const -> value_type = 0;
+    virtual auto operator / (const_reference) const -> value_type = 0;
+    virtual auto operator % (const_reference) const -> value_type = 0;
 
     virtual auto operator ==(const_reference) const -> bool = 0;
     virtual auto operator !=(const_reference) const -> bool = 0;
diff --git a/include/meevax/kernel/pair.hpp b/include/meevax/kernel/pair.hpp
index 760ce6091..d2a11a1d0 100644
--- a/include/meevax/kernel/pair.hpp
+++ b/include/meevax/kernel/pair.hpp
@@ -28,16 +28,16 @@ inline namespace kernel
   template <typename T>
   using pair_of = std::pair<T, T>;
 
-  struct pair : public pair_of<lvalue>
+  struct pair : public pair_of<value_type>
               , public top<pair>
   {
     explicit pair(const_reference a = unit, const_reference b = unit)
-      : pair_of<lvalue> { a, b }
+      : pair_of<value_type> { a, b }
     {}
 
     template <typename... Ts, typename = typename std::enable_if<(1 < sizeof...(Ts))>::type>
     explicit pair(const_reference a, Ts&&... xs)
-      : pair_of<lvalue> { a, make<pair>(std::forward<decltype(xs)>(xs)...) }
+      : pair_of<value_type> { a, make<pair>(std::forward<decltype(xs)>(xs)...) }
     {}
 
     virtual ~pair() = default;
diff --git a/include/meevax/kernel/procedure.hpp b/include/meevax/kernel/procedure.hpp
index 94d3b6d92..5d07b9c83 100644
--- a/include/meevax/kernel/procedure.hpp
+++ b/include/meevax/kernel/procedure.hpp
@@ -24,7 +24,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  #define PROCEDURE(...) meevax::lvalue __VA_ARGS__(meevax::const_reference xs)
+  #define PROCEDURE(...) meevax::value_type __VA_ARGS__(meevax::const_reference xs)
 
   struct procedure : public description
   {
diff --git a/include/meevax/kernel/ratio.hpp b/include/meevax/kernel/ratio.hpp
index 67647fdd1..de616a753 100644
--- a/include/meevax/kernel/ratio.hpp
+++ b/include/meevax/kernel/ratio.hpp
@@ -32,9 +32,9 @@ inline namespace kernel
 
     explicit ratio(std::string const&, int = 0);
 
-    auto exact() const -> lvalue override;
+    auto exact() const -> value_type override;
 
-    auto inexact() const -> lvalue override;
+    auto inexact() const -> value_type override;
 
     auto denominator() const -> const_reference;
 
@@ -56,9 +56,9 @@ inline namespace kernel
 
     auto reduce() const -> ratio;
 
-    auto simple() const -> lvalue;
+    auto simple() const -> value_type;
 
-    #define DEFINE(NAME) auto NAME() const -> lvalue override
+    #define DEFINE(NAME) auto NAME() const -> value_type override
 
     DEFINE(sin); DEFINE(asin); DEFINE(sinh); DEFINE(asinh); DEFINE(exp);
     DEFINE(cos); DEFINE(acos); DEFINE(cosh); DEFINE(acosh); DEFINE(log);
@@ -71,18 +71,18 @@ inline namespace kernel
 
     #undef DEFINE
 
-    #define DEFINE(NAME) auto NAME(const_reference) const -> lvalue override
+    #define DEFINE(NAME) auto NAME(const_reference) const -> value_type override
 
     DEFINE(atan2);
     DEFINE(pow);
 
     #undef DEFINE
 
-    auto operator + (const_reference) const -> lvalue override;
-    auto operator - (const_reference) const -> lvalue override;
-    auto operator * (const_reference) const -> lvalue override;
-    auto operator / (const_reference) const -> lvalue override;
-    auto operator % (const_reference) const -> lvalue override;
+    auto operator + (const_reference) const -> value_type override;
+    auto operator - (const_reference) const -> value_type override;
+    auto operator * (const_reference) const -> value_type override;
+    auto operator / (const_reference) const -> value_type override;
+    auto operator % (const_reference) const -> value_type override;
 
     auto operator ==(const_reference) const -> bool override;
     auto operator !=(const_reference) const -> bool override;
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index c546e8371..48c472efb 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -197,7 +197,7 @@ inline namespace kernel
       };
     }
 
-    auto integer = [](std::string const& token, auto radix = 10) -> lvalue
+    auto integer = [](std::string const& token, auto radix = 10) -> value_type
     {
       auto const result = exact_integer(token, radix);
       return make(result);
@@ -208,7 +208,7 @@ inline namespace kernel
       return meevax::ratio(token, radix).simple();
     };
 
-    auto decimal = [](std::string const& token, auto) -> lvalue
+    auto decimal = [](std::string const& token, auto) -> value_type
     {
       auto const result = double_float(token);
       return make(result);
@@ -248,7 +248,7 @@ inline namespace kernel
     using char_type = typename std::istream::char_type;
 
   public:
-    static inline std::unordered_map<std::string, lvalue> symbols {};
+    static inline std::unordered_map<std::string, value_type> symbols {};
 
     inline auto char_ready() const
     {
@@ -271,7 +271,7 @@ inline namespace kernel
       }
     }
 
-    inline auto read(std::istream & is) -> lvalue
+    inline auto read(std::istream & is) -> value_type
     {
       for (auto head = std::istream_iterator<char_type>(is); head != std::istream_iterator<char_type>(); ++head)
       {
@@ -427,7 +427,7 @@ inline namespace kernel
       return read(is);
     }
 
-    inline auto read(const_reference x) -> lvalue
+    inline auto read(const_reference x) -> value_type
     {
       if (x.is_also<std::istream>())
       {
@@ -439,7 +439,7 @@ inline namespace kernel
       }
     }
 
-    inline auto read() -> lvalue
+    inline auto read() -> value_type
     {
       let const result = read(standard_input);
 
@@ -448,7 +448,7 @@ inline namespace kernel
       return result;
     }
 
-    inline auto read(std::string const& s) -> lvalue
+    inline auto read(std::string const& s) -> value_type
     {
       return read(std::stringstream(s));
     }
diff --git a/include/meevax/kernel/string.hpp b/include/meevax/kernel/string.hpp
index 66c4d6ba6..932c9f860 100644
--- a/include/meevax/kernel/string.hpp
+++ b/include/meevax/kernel/string.hpp
@@ -45,9 +45,9 @@ inline namespace kernel
       : string { cat(std::forward<decltype(xs)>(xs)...) }
     {}
 
-    auto list(size_type, size_type) const -> lvalue;
+    auto list(size_type, size_type) const -> meevax::value_type;
 
-    auto list(size_type = 0) const -> lvalue;
+    auto list(size_type = 0) const -> meevax::value_type;
 
     operator std::string() const; // write-string (for display)
   };
diff --git a/include/meevax/kernel/syntax.hpp b/include/meevax/kernel/syntax.hpp
index d18713421..48d4257f2 100644
--- a/include/meevax/kernel/syntax.hpp
+++ b/include/meevax/kernel/syntax.hpp
@@ -27,7 +27,7 @@
     [[maybe_unused]] environment &   current_environment,                      \
     [[maybe_unused]] const_reference current_expression,                       \
     [[maybe_unused]] const_reference current_scope,                            \
-    [[maybe_unused]] const_reference current_continuation) -> lvalue
+    [[maybe_unused]] const_reference current_continuation) -> value_type
 
 namespace meevax
 {
diff --git a/include/meevax/kernel/vector.hpp b/include/meevax/kernel/vector.hpp
index 6ebffc956..3fc89e4ee 100644
--- a/include/meevax/kernel/vector.hpp
+++ b/include/meevax/kernel/vector.hpp
@@ -25,10 +25,9 @@ inline namespace kernel
 {
   enum class for_each_in_tag {} constexpr for_each_in {};
 
-  struct vector
-    : public std::vector<lvalue>
+  struct vector : public std::vector<value_type>
   {
-    using std::vector<lvalue>::vector;
+    using std::vector<meevax::value_type>::vector;
 
     template <typename InputIterator>
     explicit vector(for_each_in_tag, InputIterator from, InputIterator to)
diff --git a/src/kernel/constant.cpp b/src/kernel/constant.cpp
index 096fe13d8..f0bb6fa0f 100644
--- a/src/kernel/constant.cpp
+++ b/src/kernel/constant.cpp
@@ -21,7 +21,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  std::unordered_map<std::string, lvalue> const constants
+  std::unordered_map<std::string, value_type> const constants
   {
     // R7RS 7.1.1. Lexical structure
     { "+inf.0", make<double_float>(+double_float::infinity()) },
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 695fcb8d8..8ff52c91d 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -31,7 +31,7 @@ inline namespace kernel
     return (*this)[intern(name)];
   }
 
-  auto environment::apply(const_reference f, const_reference xs) -> lvalue
+  auto environment::apply(const_reference f, const_reference xs) -> value_type
   {
     assert(f.is<closure>() or f.is<procedure>() or f.is<continuation>());
 
@@ -63,7 +63,7 @@ inline namespace kernel
     define(intern(name), value);
   }
 
-  auto environment::evaluate(const_reference expression) -> lvalue
+  auto environment::evaluate(const_reference expression) -> value_type
   {
     if (expression.is<pair>() and car(expression).is<symbol>()
                               and car(expression).as<symbol>().value == "define-library")
@@ -108,12 +108,12 @@ inline namespace kernel
     }
   }
 
-  auto environment::execute() -> lvalue
+  auto environment::execute() -> value_type
   {
     return trace ? machine::execute<true>() : machine::execute();
   }
 
-  auto environment::execute(const_reference code) -> lvalue
+  auto environment::execute(const_reference code) -> value_type
   {
     c = code;
     return execute();
@@ -129,7 +129,7 @@ inline namespace kernel
     return second;
   }
 
-  auto resolve_import_set(const_reference import_set) -> lvalue
+  auto resolve_import_set(const_reference import_set) -> value_type
   {
     if (car(import_set).as<symbol>().value == "only")
     {
@@ -176,7 +176,7 @@ inline namespace kernel
     import_(read(import_set));
   }
 
-  auto environment::load(std::string const& s) -> lvalue
+  auto environment::load(std::string const& s) -> value_type
   {
     if (let port = make<input_file_port>(s); port and port.as<input_file_port>().is_open())
     {
@@ -203,7 +203,7 @@ inline namespace kernel
     return first;
   }
 
-  auto environment::identify(const_reference variable, const_reference scope) const -> lvalue
+  auto environment::identify(const_reference variable, const_reference scope) const -> value_type
   {
     if (not variable.is_also<identifier>())
     {
@@ -219,7 +219,7 @@ inline namespace kernel
     }
   }
 
-  auto environment::identify(const_reference variable, const_reference scope) -> lvalue
+  auto environment::identify(const_reference variable, const_reference scope) -> value_type
   {
     if (not variable.is_also<identifier>())
     {
diff --git a/src/kernel/exact_integer.cpp b/src/kernel/exact_integer.cpp
index 94c169390..1c01fb7c9 100644
--- a/src/kernel/exact_integer.cpp
+++ b/src/kernel/exact_integer.cpp
@@ -32,7 +32,7 @@ inline namespace kernel
     mpz_init(value);
   }
 
-  exact_integer::exact_integer(value_type given) noexcept
+  exact_integer::exact_integer(mpz_t given) noexcept
   {
     mpz_init_set(value, given);
   }
@@ -141,7 +141,7 @@ inline namespace kernel
     }
   }
 
-  auto exact_integer::exact() const -> lvalue
+  auto exact_integer::exact() const -> value_type
   {
     return make(*this);
   }
@@ -160,7 +160,7 @@ inline namespace kernel
     return result;
   }
 
-  auto exact_integer::inexact() const -> lvalue
+  auto exact_integer::inexact() const -> value_type
   {
     return make<double_float>(static_cast<double>(*this));
   }
@@ -205,7 +205,7 @@ inline namespace kernel
   }
 
   #define DEFINE(NAME)                                                         \
-  auto exact_integer::NAME() const -> lvalue                                   \
+  auto exact_integer::NAME() const -> value_type                               \
   {                                                                            \
     if (const double_float n { std::NAME(static_cast<double>(*this)) }; n.is_integer()) \
     {                                                                          \
@@ -229,7 +229,7 @@ inline namespace kernel
   #undef DEFINE
 
   #define DEFINE(NAME)                                                         \
-  auto exact_integer::NAME(const_reference x) const -> lvalue                  \
+  auto exact_integer::NAME(const_reference x) const -> value_type              \
   {                                                                            \
     if (const double_float n {                                                 \
           std::NAME(static_cast<double>(*this),                                \
diff --git a/src/kernel/identity.cpp b/src/kernel/identity.cpp
index fcde5f6e2..554d3c978 100644
--- a/src/kernel/identity.cpp
+++ b/src/kernel/identity.cpp
@@ -60,12 +60,12 @@ inline namespace kernel
     return second;
   }
 
-  auto absolute::make_load_mnemonic() const -> lvalue
+  auto absolute::make_load_mnemonic() const -> value_type
   {
     return make(mnemonic::load_absolute);
   }
 
-  auto absolute::make_store_mnemonic() const -> lvalue
+  auto absolute::make_store_mnemonic() const -> value_type
   {
     return make(mnemonic::store_absolute);
   }
@@ -90,12 +90,12 @@ inline namespace kernel
                     cdr(second).template as<std::uint32_t>());
   }
 
-  auto relative::make_load_mnemonic() const -> lvalue
+  auto relative::make_load_mnemonic() const -> value_type
   {
     return make(mnemonic::load_relative);
   }
 
-  auto relative::make_store_mnemonic() const -> lvalue
+  auto relative::make_store_mnemonic() const -> value_type
   {
     return make(mnemonic::store_relative);
   }
@@ -115,12 +115,12 @@ inline namespace kernel
                      cdr(second).template as<std::uint32_t>());
   }
 
-  auto variadic::make_load_mnemonic() const -> lvalue
+  auto variadic::make_load_mnemonic() const -> value_type
   {
     return make(mnemonic::load_variadic);
   }
 
-  auto variadic::make_store_mnemonic() const -> lvalue
+  auto variadic::make_store_mnemonic() const -> value_type
   {
     return make(mnemonic::store_variadic);
   }
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 01d0baabc..dc76318a5 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -443,7 +443,7 @@ inline namespace kernel
       }
     });
 
-    define<procedure>("char-codepoint", [](let const& xs) -> lvalue
+    define<procedure>("char-codepoint", [](let const& xs) -> value_type
     {
       if (auto c = car(xs).as<character>(); std::isdigit(c.codepoint))
       {
@@ -729,7 +729,7 @@ inline namespace kernel
 
   library::library(exception_library_t)
   {
-    define<procedure>("throw", [](let const& xs) -> lvalue
+    define<procedure>("throw", [](let const& xs) -> value_type
     {
       throw car(xs);
     });
@@ -861,7 +861,7 @@ inline namespace kernel
       return make<string>(car(xs).as<std::ostringstream>().str());
     });
 
-    define<procedure>("%read-char", [](let const& xs) -> lvalue
+    define<procedure>("%read-char", [](let const& xs) -> value_type
     {
       try
       {
@@ -877,7 +877,7 @@ inline namespace kernel
       }
     });
 
-    define<procedure>("%peek-char", [](let const& xs) -> lvalue
+    define<procedure>("%peek-char", [](let const& xs) -> value_type
     {
       try
       {
@@ -993,7 +993,7 @@ inline namespace kernel
 
   library::library(read_library_t)
   {
-    define<procedure>("%read", [this](let const& xs) -> lvalue
+    define<procedure>("%read", [this](let const& xs) -> value_type
     {
       try
       {
@@ -1118,7 +1118,7 @@ inline namespace kernel
 
   library::library(context_library_t)
   {
-    define<procedure>("emergency-exit", [](let const& xs) -> lvalue
+    define<procedure>("emergency-exit", [](let const& xs) -> value_type
     {
       switch (length(xs))
       {
@@ -1282,7 +1282,7 @@ inline namespace kernel
     export_(read(export_spec));
   }
 
-  auto library::resolve_export_specs() -> lvalue
+  auto library::resolve_export_specs() -> value_type
   {
     let bindings = unit;
 
diff --git a/src/kernel/list.cpp b/src/kernel/list.cpp
index 3431300db..c1c212de7 100644
--- a/src/kernel/list.cpp
+++ b/src/kernel/list.cpp
@@ -20,22 +20,22 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto take(const_reference x, std::size_t size) -> lvalue
+  auto take(const_reference x, std::size_t size) -> value_type
   {
     return 0 < size ? cons(car(x), take(cdr(x), --size)) : unit;
   }
 
-  auto append2(const_reference x, const_reference y) -> lvalue
+  auto append2(const_reference x, const_reference y) -> value_type
   {
     return x.is<null>() ? y : cons(car(x), append2(cdr(x), y));
   }
 
-  auto reverse(const_reference x) -> lvalue
+  auto reverse(const_reference x) -> value_type
   {
     return x ? append2(reverse(cdr(x)), list(car(x))) : unit;
   }
 
-  auto zip(const_reference x, const_reference y) -> lvalue
+  auto zip(const_reference x, const_reference y) -> value_type
   {
     if (x.is<null>() and y.is<null>())
     {
@@ -51,12 +51,12 @@ inline namespace kernel
     }
   }
 
-  auto unzip1(const_reference xs) -> lvalue
+  auto unzip1(const_reference xs) -> value_type
   {
     return map(car, xs);
   }
 
-  auto unzip2(const_reference xs) -> std::tuple<lvalue, lvalue>
+  auto unzip2(const_reference xs) -> std::tuple<value_type, value_type>
   {
     if (xs.is<null>())
     {
diff --git a/src/kernel/number.cpp b/src/kernel/number.cpp
index 639c126eb..990c7a2ba 100644
--- a/src/kernel/number.cpp
+++ b/src/kernel/number.cpp
@@ -20,17 +20,17 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto exact_integer::operator * (const_reference b) const -> lvalue { return apply(mul, *this, b); }
-  auto exact_integer::operator + (const_reference b) const -> lvalue { return apply(add, *this, b); }
-  auto exact_integer::operator - (const_reference b) const -> lvalue { return apply(sub, *this, b); }
-  auto exact_integer::operator / (const_reference b) const -> lvalue { return apply(div, *this, b); }
-  auto exact_integer::operator % (const_reference b) const -> lvalue { return apply(mod, *this, b); }
-  auto exact_integer::operator !=(const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, b); }
-  auto exact_integer::operator < (const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, b); }
-  auto exact_integer::operator <=(const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, b); }
-  auto exact_integer::operator ==(const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, b); }
-  auto exact_integer::operator > (const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, b); }
-  auto exact_integer::operator >=(const_reference b) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, b); }
+  auto exact_integer::operator * (const_reference b) const -> value_type { return apply(mul, *this, b); }
+  auto exact_integer::operator + (const_reference b) const -> value_type { return apply(add, *this, b); }
+  auto exact_integer::operator - (const_reference b) const -> value_type { return apply(sub, *this, b); }
+  auto exact_integer::operator / (const_reference b) const -> value_type { return apply(div, *this, b); }
+  auto exact_integer::operator % (const_reference b) const -> value_type { return apply(mod, *this, b); }
+  auto exact_integer::operator !=(const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, b); }
+  auto exact_integer::operator < (const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, b); }
+  auto exact_integer::operator <=(const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, b); }
+  auto exact_integer::operator ==(const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, b); }
+  auto exact_integer::operator > (const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, b); }
+  auto exact_integer::operator >=(const_reference b) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, b); }
 
   auto operator * (exact_integer const& a, exact_integer const& b) -> exact_integer { return exact_integer(mul, a, b); }
   auto operator + (exact_integer const& a, exact_integer const& b) -> exact_integer { return exact_integer(add, a, b); }
@@ -56,17 +56,17 @@ inline namespace kernel
   auto operator > (exact_integer const& a, ratio const& b) -> bool  { auto const x = b.reduce(); return x.is_integer() ? a >  x.numerator().as<exact_integer>() : false; }
   auto operator >=(exact_integer const& a, ratio const& b) -> bool  { auto const x = b.reduce(); return x.is_integer() ? a >= x.numerator().as<exact_integer>() : false; }
 
-  auto ratio::operator * (const_reference x) const -> lvalue { return apply(mul, *this, x); }
-  auto ratio::operator + (const_reference x) const -> lvalue { return apply(add, *this, x); }
-  auto ratio::operator - (const_reference x) const -> lvalue { return apply(sub, *this, x); }
-  auto ratio::operator / (const_reference x) const -> lvalue { return apply(div, *this, x); }
-  auto ratio::operator % (const_reference x) const -> lvalue { return apply(mod, *this, x); }
-  auto ratio::operator !=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, x); }
-  auto ratio::operator < (const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, x); }
-  auto ratio::operator <=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, x); }
-  auto ratio::operator ==(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, x); }
-  auto ratio::operator > (const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, x); }
-  auto ratio::operator >=(const_reference x) const -> bool   { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, x); }
+  auto ratio::operator * (const_reference x) const -> value_type { return apply(mul, *this, x); }
+  auto ratio::operator + (const_reference x) const -> value_type { return apply(add, *this, x); }
+  auto ratio::operator - (const_reference x) const -> value_type { return apply(sub, *this, x); }
+  auto ratio::operator / (const_reference x) const -> value_type { return apply(div, *this, x); }
+  auto ratio::operator % (const_reference x) const -> value_type { return apply(mod, *this, x); }
+  auto ratio::operator !=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a != b; }, *this, x); }
+  auto ratio::operator < (const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <  b; }, *this, x); }
+  auto ratio::operator <=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a <= b; }, *this, x); }
+  auto ratio::operator ==(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a == b; }, *this, x); }
+  auto ratio::operator > (const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >  b; }, *this, x); }
+  auto ratio::operator >=(const_reference x) const -> bool       { return apply<bool>([](auto&& a, auto&& b) { return a >= b; }, *this, x); }
 
   auto operator * (ratio const& a, exact_integer const& b) -> ratio { return ratio(make(a.numerator().as<exact_integer>() * b), cdr(a)); }
   auto operator + (ratio const& a, exact_integer const& b) -> ratio { return ratio(make(a.numerator().as<exact_integer>() + a.denominator().as<exact_integer>() * b), cdr(a)); }
diff --git a/src/kernel/ratio.cpp b/src/kernel/ratio.cpp
index 41d0438c5..3c23d610b 100644
--- a/src/kernel/ratio.cpp
+++ b/src/kernel/ratio.cpp
@@ -54,7 +54,7 @@ inline namespace kernel
     }
   }
 
-  auto ratio::exact() const -> lvalue
+  auto ratio::exact() const -> value_type
   {
     return simple();
   }
@@ -69,7 +69,7 @@ inline namespace kernel
     return second;
   }
 
-  auto ratio::inexact() const -> lvalue
+  auto ratio::inexact() const -> value_type
   {
     return make<double_float>(numerator().as<exact_integer>().inexact().as<double_float>() / denominator().as<exact_integer>().inexact().as<double_float>());
   }
@@ -106,7 +106,7 @@ inline namespace kernel
     }
   }
 
-  auto ratio::simple() const -> lvalue
+  auto ratio::simple() const -> value_type
   {
     if (auto x = reduce(); x.is_integer())
     {
@@ -119,7 +119,7 @@ inline namespace kernel
   }
 
   #define DEFINE(NAME)                                                         \
-  auto ratio::NAME() const -> lvalue                                           \
+  auto ratio::NAME() const -> value_type                                       \
   {                                                                            \
     if (const double_float x {                                                 \
           std::NAME(numerator().as<exact_integer>().inexact().as<double_float>() / denominator().as<exact_integer>().inexact().as<double_float>()) \
@@ -146,7 +146,7 @@ inline namespace kernel
   #undef DEFINE
 
   #define DEFINE(NAME)                                                         \
-  auto ratio::NAME(const_reference x) const -> lvalue                          \
+  auto ratio::NAME(const_reference x) const -> value_type                      \
   {                                                                            \
     if (const double_float n {                                                 \
           std::NAME(numerator().as<exact_integer>().inexact().as<double_float>() / denominator().as<exact_integer>().inexact().as<double_float>(), \
diff --git a/src/kernel/string.cpp b/src/kernel/string.cpp
index 49b5f7917..27e99c4ae 100644
--- a/src/kernel/string.cpp
+++ b/src/kernel/string.cpp
@@ -85,7 +85,7 @@ inline namespace kernel
     : string { std::stringstream(s + "\"") }
   {}
 
-  auto string::list(size_type from, size_type to) const -> lvalue
+  auto string::list(size_type from, size_type to) const -> meevax::value_type
   {
     let x = unit;
 
@@ -97,7 +97,7 @@ inline namespace kernel
     return x;
   }
 
-  auto string::list(size_type from) const -> lvalue
+  auto string::list(size_type from) const -> meevax::value_type
   {
     return list(from, size());
   }

From d826d99874fd003e925de59d789adae908a99159 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 02:20:43 +0900
Subject: [PATCH 05/36] Add new type alias `external_representation`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                                |  6 ++---
 VERSION                                  |  2 +-
 include/meevax/kernel/character.hpp      |  4 ++-
 include/meevax/kernel/constant.hpp       |  2 +-
 include/meevax/kernel/environment.hpp    |  8 +++---
 include/meevax/kernel/error.hpp          |  2 +-
 include/meevax/kernel/exact_integer.hpp  |  8 +++---
 include/meevax/kernel/floating_point.hpp |  6 ++---
 include/meevax/kernel/intrinsic.hpp      |  2 +-
 include/meevax/kernel/library.hpp        |  6 ++---
 include/meevax/kernel/machine.hpp        |  2 +-
 include/meevax/kernel/overview.hpp       |  2 ++
 include/meevax/kernel/procedure.hpp      | 11 ++++----
 include/meevax/kernel/ratio.hpp          |  2 +-
 include/meevax/kernel/reader.hpp         | 32 ++++++++++++------------
 include/meevax/kernel/string.hpp         |  4 +--
 include/meevax/kernel/symbol.hpp         |  2 +-
 include/meevax/kernel/syntax.hpp         |  3 ++-
 src/kernel/character.cpp                 |  4 +--
 src/kernel/constant.cpp                  |  2 +-
 src/kernel/environment.cpp               | 12 ++++-----
 src/kernel/error.cpp                     |  6 ++---
 src/kernel/exact_integer.cpp             | 10 ++++----
 src/kernel/library.cpp                   | 12 ++++-----
 src/kernel/port.cpp                      |  2 +-
 src/kernel/procedure.cpp                 | 10 ++++----
 src/kernel/ratio.cpp                     |  2 +-
 src/kernel/string.cpp                    | 10 ++++----
 src/kernel/syntax.cpp                    |  2 +-
 test/list.cpp                            | 22 ++++++++--------
 test/nan_boxing_pointer.cpp              |  4 +--
 31 files changed, 104 insertions(+), 98 deletions(-)

diff --git a/README.md b/README.md
index 028c6ab0a..9cea4ede9 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.85.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.86.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.85_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.86_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.85
+Meevax Lisp System, version 0.4.86
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index aab4c6e65..9cad07ba5 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.85
+0.4.86
diff --git a/include/meevax/kernel/character.hpp b/include/meevax/kernel/character.hpp
index 6d6d05cdb..730a89838 100644
--- a/include/meevax/kernel/character.hpp
+++ b/include/meevax/kernel/character.hpp
@@ -19,6 +19,8 @@
 
 #include <iostream>
 
+#include <meevax/kernel/pair.hpp>
+
 namespace meevax
 {
 inline namespace kernel
@@ -37,7 +39,7 @@ inline namespace kernel
 
     operator value_type() const; // char->integer
 
-    explicit operator std::string() const; // write-char (for display)
+    explicit operator external_representation() const; // write-char (for display)
   };
 
   auto operator <<(std::ostream &, character const&) -> std::ostream &; // write
diff --git a/include/meevax/kernel/constant.hpp b/include/meevax/kernel/constant.hpp
index dfdd9a564..246d29741 100644
--- a/include/meevax/kernel/constant.hpp
+++ b/include/meevax/kernel/constant.hpp
@@ -23,7 +23,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  extern std::unordered_map<std::string, value_type> const constants;
+  extern std::unordered_map<external_representation, value_type> const constants;
 } // namespace kernel
 } // namespace meevax
 
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 8fff4a5d4..7a762d2e2 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -52,7 +52,7 @@ inline namespace kernel
 
     explicit environment(environment const&) = default;
 
-    template <typename... Ts, REQUIRES(std::is_convertible<Ts, std::string>...)>
+    template <typename... Ts, REQUIRES(std::is_convertible<Ts, external_representation>...)>
     explicit environment(Ts&&... xs)
     {
       (import(xs), ...);
@@ -60,7 +60,7 @@ inline namespace kernel
 
     auto operator [](const_reference) -> const_reference;
 
-    auto operator [](std::string const&) -> const_reference;
+    auto operator [](symbol::value_type const&) -> const_reference;
 
     auto apply(const_reference, const_reference) -> value_type;
 
@@ -98,9 +98,9 @@ inline namespace kernel
 
     auto import_(const_reference) -> void;
 
-    auto import_(std::string const&) -> void;
+    auto import_(external_representation const&) -> void;
 
-    auto load(std::string const&) -> value_type;
+    auto load(external_representation const&) -> value_type;
 
     auto scope() const noexcept -> const_reference;
 
diff --git a/include/meevax/kernel/error.hpp b/include/meevax/kernel/error.hpp
index 0b66b18ef..ff421182b 100644
--- a/include/meevax/kernel/error.hpp
+++ b/include/meevax/kernel/error.hpp
@@ -52,7 +52,7 @@ inline namespace kernel
 
     virtual auto raise() const -> void;
 
-    virtual auto what() const -> std::string;
+    virtual auto what() const -> external_representation;
   };
 
   auto operator <<(std::ostream &, error const&) -> std::ostream &;
diff --git a/include/meevax/kernel/exact_integer.hpp b/include/meevax/kernel/exact_integer.hpp
index f11e5f387..ccf778d3a 100644
--- a/include/meevax/kernel/exact_integer.hpp
+++ b/include/meevax/kernel/exact_integer.hpp
@@ -46,7 +46,7 @@ inline namespace kernel
 
     explicit exact_integer(double);
 
-    explicit exact_integer(std::string const&, int = 0);
+    explicit exact_integer(external_representation const&, int = 0);
 
     explicit exact_integer(addition,                exact_integer const&, exact_integer const&);
     explicit exact_integer(subtraction,             exact_integer const&, exact_integer const&);
@@ -61,7 +61,7 @@ inline namespace kernel
 
     auto operator=(exact_integer &&) noexcept -> exact_integer &;
 
-    auto operator=(std::string const&) -> exact_integer &;
+    auto operator=(external_representation const&) -> exact_integer &;
 
     auto floor_remainder(exact_integer const&) const -> exact_integer;
 
@@ -75,7 +75,7 @@ inline namespace kernel
 
     auto is_integer() const -> bool override;
 
-    auto string(int = 10) const -> std::string;
+    auto string(int = 10) const -> external_representation;
 
     auto swap(exact_integer &) noexcept -> void;
 
@@ -114,7 +114,7 @@ inline namespace kernel
 
     explicit operator double() const;
 
-    explicit operator std::string() const;
+    explicit operator external_representation() const;
 
     auto operator + (const_reference) const -> value_type override;
     auto operator - (const_reference) const -> value_type override;
diff --git a/include/meevax/kernel/floating_point.hpp b/include/meevax/kernel/floating_point.hpp
index da2dda972..490b2b55e 100644
--- a/include/meevax/kernel/floating_point.hpp
+++ b/include/meevax/kernel/floating_point.hpp
@@ -37,7 +37,7 @@ inline namespace kernel
       : value { value }
     {}
 
-    explicit floating_point(std::string const& token) try
+    explicit floating_point(external_representation const& token) try
       : value { lexical_cast<T>(token) }
     {}
     catch (...)
@@ -95,10 +95,10 @@ inline namespace kernel
       return std::isnan(value);
     }
 
-    // TODO TEMPLATE SPECIALIZATION to<std::string>()
+    // TODO TEMPLATE SPECIALIZATION to<external_representation>()
     auto to_string() const
     {
-      return lexical_cast<std::string>(value);
+      return lexical_cast<external_representation>(value);
     }
 
     auto inexact() const -> value_type override
diff --git a/include/meevax/kernel/intrinsic.hpp b/include/meevax/kernel/intrinsic.hpp
index 20800553a..47393e254 100644
--- a/include/meevax/kernel/intrinsic.hpp
+++ b/include/meevax/kernel/intrinsic.hpp
@@ -28,7 +28,7 @@ inline namespace kernel
                    , public procedure
   {
     template <typename F, typename G>
-    explicit intrinsic(std::string const& name, F&& f, G&& g)
+    explicit intrinsic(symbol::value_type const& name, F&& f, G&& g)
       : syntax    { name, std::forward<decltype(f)>(f) }
       , procedure { name, std::forward<decltype(g)>(g) }
     {}
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 0c5026d25..91d3c8d3b 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -43,7 +43,7 @@ inline namespace kernel
 
     auto export_(const_reference) -> void;
 
-    auto export_(std::string const&) -> void;
+    auto export_(external_representation const&) -> void;
 
     auto resolve_export_specs() -> value_type;
 
@@ -82,10 +82,10 @@ inline namespace kernel
 
   auto operator <<(std::ostream &, library const&) -> std::ostream &;
 
-  extern std::unordered_map<std::string, library> libraries;
+  extern std::unordered_map<external_representation, library> libraries;
 
   template <typename... Ts>
-  auto define_library(std::string const& name, Ts&&... xs)
+  auto define_library(external_representation const& name, Ts&&... xs)
   {
     return libraries.emplace(name, std::forward<decltype(xs)>(xs)...);
   }
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 5bc119eb3..620fd0a1a 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -891,7 +891,7 @@ inline namespace kernel
     {
       if (current_context.is_tail)
       {
-        assert(lexical_cast<std::string>(current_continuation) == "(return)");
+        assert(lexical_cast<external_representation>(current_continuation) == "(return)");
 
         return compile(context(),
                        current_environment,
diff --git a/include/meevax/kernel/overview.hpp b/include/meevax/kernel/overview.hpp
index c96fb0f37..e17f720db 100644
--- a/include/meevax/kernel/overview.hpp
+++ b/include/meevax/kernel/overview.hpp
@@ -54,6 +54,8 @@ inline namespace kernel
 
   using null = std::nullptr_t;
 
+  using external_representation = std::string;
+
   struct number
   {
     #define DEFINE(NAME) virtual auto NAME() const -> value_type = 0
diff --git a/include/meevax/kernel/procedure.hpp b/include/meevax/kernel/procedure.hpp
index 5d07b9c83..be855be57 100644
--- a/include/meevax/kernel/procedure.hpp
+++ b/include/meevax/kernel/procedure.hpp
@@ -18,6 +18,7 @@
 #define INCLUDED_MEEVAX_KERNEL_PROCEDURE_HPP
 
 #include <meevax/kernel/list.hpp>
+#include <meevax/kernel/symbol.hpp>
 #include <meevax/utility/description.hpp>
 
 namespace meevax
@@ -34,13 +35,13 @@ inline namespace kernel
 
     function_type call;
 
-    explicit procedure(std::string const&, function_type const&);
+    explicit procedure(symbol::value_type const&, function_type const&);
 
-    explicit procedure(std::string const&, std::string const&);
+    explicit procedure(symbol::value_type const&, symbol::value_type const&);
 
-    static auto dlopen(std::string const&) -> void *;
+    static auto dlopen(symbol::value_type const&) -> void *;
 
-    static auto dlsym(std::string const&, void * const) -> function_pointer_type;
+    static auto dlsym(symbol::value_type const&, void * const) -> function_pointer_type;
   };
 
   auto operator <<(std::ostream &, procedure const&) -> std::ostream &;
@@ -48,7 +49,7 @@ inline namespace kernel
   struct predicate : public procedure
   {
     template <typename Callable>
-    explicit predicate(std::string const& name, Callable && call)
+    explicit predicate(symbol::value_type const& name, Callable && call)
       : procedure { name, [call](auto&&... xs) { return call(std::forward<decltype(xs)>(xs)...) ? t : f; } }
     {}
   };
diff --git a/include/meevax/kernel/ratio.hpp b/include/meevax/kernel/ratio.hpp
index de616a753..91bea4870 100644
--- a/include/meevax/kernel/ratio.hpp
+++ b/include/meevax/kernel/ratio.hpp
@@ -30,7 +30,7 @@ inline namespace kernel
 
     explicit ratio(double);
 
-    explicit ratio(std::string const&, int = 0);
+    explicit ratio(external_representation const&, int = 0);
 
     auto exact() const -> value_type override;
 
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index 48c472efb..b5f42f66e 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -102,7 +102,7 @@ inline namespace kernel
         return std::isspace(c) or one_of('"', '#', '\'', '(', ')', ',', ';', '[', ']', '`', '{', '|', '}', std::char_traits<char>::eof()); // NOTE: What read treats specially.
       };
 
-      std::string result;
+      external_representation result;
 
       for (auto c = is.peek(); not is_end(c); c = is.peek())
       {
@@ -130,7 +130,7 @@ inline namespace kernel
 
     auto character_name = [](std::istream & is)
     {
-      std::unordered_map<std::string, character::value_type> static const character_names
+      std::unordered_map<external_representation, character::value_type> static const character_names
       {
         { "alarm"    , 0x07 },
         { "backspace", 0x08 },
@@ -180,11 +180,11 @@ inline namespace kernel
 
   namespace string_to
   {
-    template <typename F, typename G, REQUIRES(std::is_invocable<F, std::string const&, int>,
-                                               std::is_invocable<G, std::string const&, int>)>
+    template <typename F, typename G, REQUIRES(std::is_invocable<F, external_representation const&, int>,
+                                               std::is_invocable<G, external_representation const&, int>)>
     auto operator |(F&& f, G&& g)
     {
-      return [=](std::string const& token, auto radix)
+      return [=](external_representation const& token, auto radix)
       {
         try
         {
@@ -197,24 +197,24 @@ inline namespace kernel
       };
     }
 
-    auto integer = [](std::string const& token, auto radix = 10) -> value_type
+    auto integer = [](external_representation const& token, auto radix = 10) -> value_type
     {
       auto const result = exact_integer(token, radix);
       return make(result);
     };
 
-    auto ratio = [](std::string const& token, auto radix = 10)
+    auto ratio = [](external_representation const& token, auto radix = 10)
     {
       return meevax::ratio(token, radix).simple();
     };
 
-    auto decimal = [](std::string const& token, auto) -> value_type
+    auto decimal = [](external_representation const& token, auto) -> value_type
     {
       auto const result = double_float(token);
       return make(result);
     };
 
-    auto flonum = [](std::string const& token, auto)
+    auto flonum = [](external_representation const& token, auto)
     {
       if (auto iter = constants.find(token); iter != std::end(constants))
       {
@@ -248,14 +248,14 @@ inline namespace kernel
     using char_type = typename std::istream::char_type;
 
   public:
-    static inline std::unordered_map<std::string, value_type> symbols {};
+    static inline std::unordered_map<external_representation, value_type> symbols {};
 
     inline auto char_ready() const
     {
       return standard_input.is_also<std::istream>() and standard_input.as<std::istream>();
     }
 
-    static auto intern(std::string const& name) -> const_reference
+    static auto intern(external_representation const& name) -> const_reference
     {
       if (auto const iter = symbols.find(name); iter != std::end(symbols))
       {
@@ -353,7 +353,7 @@ inline namespace kernel
             return read(is), read(is);
 
           case 'b': // (string->number (read) 2)
-            return string_to::number(is.peek() == '#' ? lexical_cast<std::string>(read(is)) : parse::token(is), 2);
+            return string_to::number(is.peek() == '#' ? lexical_cast<external_representation>(read(is)) : parse::token(is), 2);
 
           case 'c': // from Common Lisp
             if (let const xs = read(is); xs.is<null>())
@@ -370,7 +370,7 @@ inline namespace kernel
             }
 
           case 'd':
-            return string_to::number(is.peek() == '#' ? lexical_cast<std::string>(read(is)) : parse::token(is), 10);
+            return string_to::number(is.peek() == '#' ? lexical_cast<external_representation>(read(is)) : parse::token(is), 10);
 
           case 'e':
             return read(is).template as<number>().exact(); // NOTE: Same as #,(exact (read))
@@ -383,14 +383,14 @@ inline namespace kernel
             return read(is).template as<number>().inexact(); // NOTE: Same as #,(inexact (read))
 
           case 'o':
-            return string_to::number(is.peek() == '#' ? lexical_cast<std::string>(read(is)) : parse::token(is), 8);
+            return string_to::number(is.peek() == '#' ? lexical_cast<external_representation>(read(is)) : parse::token(is), 8);
 
           case 't':
             parse::token(is);
             return t;
 
           case 'x':
-            return string_to::number(is.peek() == '#' ? lexical_cast<std::string>(read(is)) : parse::token(is), 16);
+            return string_to::number(is.peek() == '#' ? lexical_cast<external_representation>(read(is)) : parse::token(is), 16);
 
           case '(':
             is.putback(c);
@@ -448,7 +448,7 @@ inline namespace kernel
       return result;
     }
 
-    inline auto read(std::string const& s) -> value_type
+    inline auto read(external_representation const& s) -> value_type
     {
       return read(std::stringstream(s));
     }
diff --git a/include/meevax/kernel/string.hpp b/include/meevax/kernel/string.hpp
index 932c9f860..4b69beefc 100644
--- a/include/meevax/kernel/string.hpp
+++ b/include/meevax/kernel/string.hpp
@@ -38,7 +38,7 @@ inline namespace kernel
 
     explicit string(std::istream &&);
 
-    explicit string(std::string const&);
+    explicit string(external_representation const&);
 
     template <typename... Ts>
     explicit string(decltype(cat), Ts&&... xs)
@@ -49,7 +49,7 @@ inline namespace kernel
 
     auto list(size_type = 0) const -> meevax::value_type;
 
-    operator std::string() const; // write-string (for display)
+    operator external_representation() const; // write-string (for display)
   };
 
   auto operator <<(std::ostream &, string const&) -> std::ostream &;
diff --git a/include/meevax/kernel/symbol.hpp b/include/meevax/kernel/symbol.hpp
index 221ef590f..7e9e4293e 100644
--- a/include/meevax/kernel/symbol.hpp
+++ b/include/meevax/kernel/symbol.hpp
@@ -35,7 +35,7 @@ inline namespace kernel
       : value { std::forward<decltype(xs)>(xs)... }
     {}
 
-    operator std::string() const noexcept
+    operator external_representation() const noexcept
     {
       return value;
     }
diff --git a/include/meevax/kernel/syntax.hpp b/include/meevax/kernel/syntax.hpp
index 48d4257f2..fd17e3b84 100644
--- a/include/meevax/kernel/syntax.hpp
+++ b/include/meevax/kernel/syntax.hpp
@@ -19,6 +19,7 @@
 
 #include <meevax/kernel/context.hpp>
 #include <meevax/kernel/pair.hpp>
+#include <meevax/kernel/symbol.hpp>
 #include <meevax/utility/description.hpp>
 
 #define SYNTAX(NAME)                                                           \
@@ -41,7 +42,7 @@ inline namespace kernel
 
     function_type compile;
 
-    explicit syntax(std::string const&, function_type const&);
+    explicit syntax(symbol::value_type const&, function_type const&);
   };
 
   auto operator <<(std::ostream &, syntax const&) -> std::ostream &;
diff --git a/src/kernel/character.cpp b/src/kernel/character.cpp
index 75c2f32b6..64497a514 100644
--- a/src/kernel/character.cpp
+++ b/src/kernel/character.cpp
@@ -73,7 +73,7 @@ inline namespace kernel
     return codepoint;
   }
 
-  character::operator std::string() const
+  character::operator external_representation() const
   {
     std::array<char, 5> bytes {};
 
@@ -126,7 +126,7 @@ inline namespace kernel
     case 0x7F: return os << cyan("delete"   );
 
     default:
-      return os << cyan(static_cast<std::string>(datum));
+      return os << cyan(static_cast<external_representation>(datum));
     }
   }
 
diff --git a/src/kernel/constant.cpp b/src/kernel/constant.cpp
index f0bb6fa0f..5d8847ed6 100644
--- a/src/kernel/constant.cpp
+++ b/src/kernel/constant.cpp
@@ -21,7 +21,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  std::unordered_map<std::string, value_type> const constants
+  std::unordered_map<external_representation, value_type> const constants
   {
     // R7RS 7.1.1. Lexical structure
     { "+inf.0", make<double_float>(+double_float::infinity()) },
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 8ff52c91d..0a7c2effb 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -26,7 +26,7 @@ inline namespace kernel
     return identify(name, scope()).as<absolute>().load();
   }
 
-  auto environment::operator [](std::string const& name) -> const_reference
+  auto environment::operator [](external_representation const& name) -> const_reference
   {
     return (*this)[intern(name)];
   }
@@ -58,7 +58,7 @@ inline namespace kernel
     global() = make<absolute>(name, value) | global();
   }
 
-  auto environment::define(std::string const& name, const_reference value) -> void
+  auto environment::define(external_representation const& name, const_reference value) -> void
   {
     define(intern(name), value);
   }
@@ -68,7 +68,7 @@ inline namespace kernel
     if (expression.is<pair>() and car(expression).is<symbol>()
                               and car(expression).as<symbol>().value == "define-library")
     {
-      define_library(lexical_cast<std::string>(cadr(expression)), cddr(expression));
+      define_library(lexical_cast<external_representation>(cadr(expression)), cddr(expression));
       return cadr(expression);
     }
     else if (expression.is<pair>() and car(expression).is<symbol>()
@@ -151,7 +151,7 @@ inline namespace kernel
 
       return filtered_bindings;
     }
-    else if (auto iter = libraries.find(lexical_cast<std::string>(import_set)); iter != std::end(libraries))
+    else if (auto iter = libraries.find(lexical_cast<external_representation>(import_set)); iter != std::end(libraries))
     {
       return std::get<1>(*iter).resolve_export_specs();
     }
@@ -171,12 +171,12 @@ inline namespace kernel
     }
   }
 
-  auto environment::import_(std::string const& import_set) -> void
+  auto environment::import_(external_representation const& import_set) -> void
   {
     import_(read(import_set));
   }
 
-  auto environment::load(std::string const& s) -> value_type
+  auto environment::load(external_representation const& s) -> value_type
   {
     if (let port = make<input_file_port>(s); port and port.as<input_file_port>().is_open())
     {
diff --git a/src/kernel/error.cpp b/src/kernel/error.cpp
index 710c0ca5f..040356877 100644
--- a/src/kernel/error.cpp
+++ b/src/kernel/error.cpp
@@ -35,11 +35,11 @@ inline namespace kernel
     throw *this;
   }
 
-  auto error::what() const -> std::string
+  auto error::what() const -> external_representation
   {
     std::stringstream ss {};
 
-    ss << "error: " << static_cast<std::string>(message().as<string>());
+    ss << "error: " << static_cast<external_representation>(message().as<string>());
 
     if (irritants())
     {
@@ -61,7 +61,7 @@ inline namespace kernel
     return os << magenta(")");
   }
 
-  auto raise(std::string const& message) -> void
+  auto raise(external_representation const& message) -> void
   {
     throw error(make<string>(message));
   }
diff --git a/src/kernel/exact_integer.cpp b/src/kernel/exact_integer.cpp
index 1c01fb7c9..8a6948ee7 100644
--- a/src/kernel/exact_integer.cpp
+++ b/src/kernel/exact_integer.cpp
@@ -67,7 +67,7 @@ inline namespace kernel
     mpz_init_set_d(value, rhs);
   }
 
-  exact_integer::exact_integer(std::string const& s, int radix)
+  exact_integer::exact_integer(external_representation const& s, int radix)
   {
     if (mpz_init_set_str(value, s.c_str(), radix))
     {
@@ -129,7 +129,7 @@ inline namespace kernel
     return *this;
   }
 
-  auto exact_integer::operator=(std::string const& s) -> exact_integer &
+  auto exact_integer::operator=(external_representation const& s) -> exact_integer &
   {
     if (mpz_set_str(value, s.c_str(), 0))
     {
@@ -170,7 +170,7 @@ inline namespace kernel
     return true;
   }
 
-  auto exact_integer::string(int radix) const -> std::string
+  auto exact_integer::string(int radix) const -> external_representation
   {
     auto deallocate = [](char * data)
     {
@@ -280,7 +280,7 @@ inline namespace kernel
     return mpz_get_d(value);
   }
 
-  exact_integer::operator std::string() const
+  exact_integer::operator external_representation() const
   {
     return string();
   }
@@ -315,7 +315,7 @@ inline namespace kernel
 
   auto operator <<(std::ostream & os, exact_integer const& datum) -> std::ostream &
   {
-    return os << cyan(static_cast<std::string>(datum));
+    return os << cyan(static_cast<external_representation>(datum));
   }
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index dc76318a5..8e4e68068 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -178,7 +178,7 @@ inline namespace kernel
 
     define<procedure>("number->string", [](auto&& xs)
     {
-      return make<string>(lexical_cast<std::string>(car(xs)));
+      return make<string>(lexical_cast<external_representation>(car(xs)));
     });
 
     export_("number?");
@@ -925,7 +925,7 @@ inline namespace kernel
 
     define<procedure>("put-char", [](let const& xs)
     {
-      cadr(xs).as<std::ostream>() << static_cast<std::string>(car(xs).as<character>());
+      cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<character>());
       return unspecified_object;
     });
 
@@ -934,7 +934,7 @@ inline namespace kernel
       switch (length(xs))
       {
       case 2:
-        cadr(xs).as<std::ostream>() << static_cast<std::string>(car(xs).as<string>());
+        cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<string>());
         break;
 
       case 3: // TODO
@@ -1026,7 +1026,7 @@ inline namespace kernel
       {
         if (x.is<string>())
         {
-          std::cout << static_cast<std::string>(x.as<string>());
+          std::cout << static_cast<external_representation>(x.as<string>());
         }
         else
         {
@@ -1277,7 +1277,7 @@ inline namespace kernel
     export_specs.push_back(export_spec);
   }
 
-  auto library::export_(std::string const& export_spec) -> void
+  auto library::export_(external_representation const& export_spec) -> void
   {
     export_(read(export_spec));
   }
@@ -1321,6 +1321,6 @@ inline namespace kernel
     return os << library.global();
   }
 
-  std::unordered_map<std::string, library> libraries {};
+  std::unordered_map<external_representation, library> libraries {};
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/port.cpp b/src/kernel/port.cpp
index 47abe9acc..bdc9eeb9b 100644
--- a/src/kernel/port.cpp
+++ b/src/kernel/port.cpp
@@ -45,7 +45,7 @@ inline namespace kernel
   #undef DEFINE
 
   #define DEFINE(TYPENAME, FILE_STREAM, NAME)                                  \
-  TYPENAME::TYPENAME(std::string const& name)                                  \
+  TYPENAME::TYPENAME(external_representation const& name)                      \
     : description { name }                                                     \
     , FILE_STREAM { name }                                                     \
   {}                                                                           \
diff --git a/src/kernel/procedure.cpp b/src/kernel/procedure.cpp
index f2df44b0c..1ff099e2d 100644
--- a/src/kernel/procedure.cpp
+++ b/src/kernel/procedure.cpp
@@ -27,17 +27,17 @@ namespace meevax
 {
 inline namespace kernel
 {
-  procedure::procedure(std::string const& name, function_type const& call)
+  procedure::procedure(symbol::value_type const& name, function_type const& call)
     : description { name }
     , call { call }
   {}
 
-  procedure::procedure(std::string const& name, std::string const& libfoo_so)
+  procedure::procedure(symbol::value_type const& name, symbol::value_type const& libfoo_so)
     : description { name }
     , call { dlsym(name, dlopen(libfoo_so)) }
   {}
 
-  auto procedure::dlopen(std::string const& libfoo_so) -> void *
+  auto procedure::dlopen(symbol::value_type const& libfoo_so) -> void *
   {
     auto dlclose = [](void * const handle)
     {
@@ -48,7 +48,7 @@ inline namespace kernel
     };
 
     static std::unordered_map<
-      std::string, std::unique_ptr<void, decltype(dlclose)>
+      symbol::value_type, std::unique_ptr<void, decltype(dlclose)>
     > dynamic_libraries {};
 
     ::dlerror(); // clear
@@ -75,7 +75,7 @@ inline namespace kernel
     }
   }
 
-  auto procedure::dlsym(std::string const& name, void * const handle) -> function_pointer_type
+  auto procedure::dlsym(symbol::value_type const& name, void * const handle) -> function_pointer_type
   {
     if (auto address = ::dlsym(handle, name.c_str()); address)
     {
diff --git a/src/kernel/ratio.cpp b/src/kernel/ratio.cpp
index 3c23d610b..af0b995bc 100644
--- a/src/kernel/ratio.cpp
+++ b/src/kernel/ratio.cpp
@@ -34,7 +34,7 @@ inline namespace kernel
     mpq_clear(value);
   }
 
-  ratio::ratio(std::string const& token, int radix)
+  ratio::ratio(external_representation const& token, int radix)
   {
     std::regex static const pattern { "([+-]?[0-9a-f]+)/([0-9a-f]+)" };
 
diff --git a/src/kernel/string.cpp b/src/kernel/string.cpp
index 27e99c4ae..7fefc8ce3 100644
--- a/src/kernel/string.cpp
+++ b/src/kernel/string.cpp
@@ -44,7 +44,7 @@ inline namespace kernel
         case 'v': emplace_back('\v'); break;
 
         case 'x':
-          if (std::string token; std::getline(is, token, ';') and is.ignore(1))
+          if (external_representation token; std::getline(is, token, ';') and is.ignore(1))
           {
             if (std::stringstream ss; ss << std::hex << token)
             {
@@ -81,7 +81,7 @@ inline namespace kernel
     : string { is }
   {}
 
-  string::string(std::string const& s)
+  string::string(external_representation const& s)
     : string { std::stringstream(s + "\"") }
   {}
 
@@ -102,13 +102,13 @@ inline namespace kernel
     return list(from, size());
   }
 
-  string::operator std::string() const
+  string::operator external_representation() const
   {
-    std::string result;
+    external_representation result;
 
     for (character const& each : *this)
     {
-      result.append(static_cast<std::string>(each));
+      result.append(static_cast<external_representation>(each));
     }
 
     return result;
diff --git a/src/kernel/syntax.cpp b/src/kernel/syntax.cpp
index 6b9f7a763..79d58ac36 100644
--- a/src/kernel/syntax.cpp
+++ b/src/kernel/syntax.cpp
@@ -20,7 +20,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  syntax::syntax(std::string const& name, function_type const& compile)
+  syntax::syntax(external_representation const& name, function_type const& compile)
     : description { name }
     , compile { compile }
   {}
diff --git a/test/list.cpp b/test/list.cpp
index 1da9c62f2..d91c57514 100644
--- a/test/list.cpp
+++ b/test/list.cpp
@@ -12,24 +12,24 @@ auto main() -> int
       c = make<symbol>("c"),
       d = make<symbol>("d");
 
-  assert(lexical_cast<std::string>(cons(a, unit)) == "(a)");
-  assert(lexical_cast<std::string>(cons(list(a), list(b, c, d))) == "((a) b c d)");
-  assert(lexical_cast<std::string>(cons(make<string>("a"), list(b, c))) == "(\"a\" b c)");
-  assert(lexical_cast<std::string>(cons(a, make<exact_integer>(3))) == "(a . 3)");
-  assert(lexical_cast<std::string>(cons(list(a, b), c)) == "((a b) . c)");
+  assert(lexical_cast<external_representation>(cons(a, unit)) == "(a)");
+  assert(lexical_cast<external_representation>(cons(list(a), list(b, c, d))) == "((a) b c d)");
+  assert(lexical_cast<external_representation>(cons(make<string>("a"), list(b, c))) == "(\"a\" b c)");
+  assert(lexical_cast<external_representation>(cons(a, make<exact_integer>(3))) == "(a . 3)");
+  assert(lexical_cast<external_representation>(cons(list(a, b), c)) == "((a b) . c)");
 
-  assert(lexical_cast<std::string>(list(a, make<exact_integer>(3 + 4), c)) == "(a 7 c)");
-  assert(lexical_cast<std::string>(list()) == "()");
+  assert(lexical_cast<external_representation>(list(a, make<exact_integer>(3 + 4), c)) == "(a 7 c)");
+  assert(lexical_cast<external_representation>(list()) == "()");
 
-  assert(lexical_cast<std::string>(xcons(list(b, c), a)) == "(a b c)");
+  assert(lexical_cast<external_representation>(xcons(list(b, c), a)) == "(a b c)");
 
-  assert(lexical_cast<std::string>(make_list(4, c)) == "(c c c c)");
+  assert(lexical_cast<external_representation>(make_list(4, c)) == "(c c c c)");
 
-  assert(lexical_cast<std::string>(list_tabulate(4, [](auto&&... xs) { return make<exact_integer>(xs...); })) == "(0 1 2 3)");
+  assert(lexical_cast<external_representation>(list_tabulate(4, [](auto&&... xs) { return make<exact_integer>(xs...); })) == "(0 1 2 3)");
 
   let x1 = list(a, b, c);
   let x2 = list_copy(x1);
-  assert(lexical_cast<std::string>(x2) == "(a b c)");
+  assert(lexical_cast<external_representation>(x2) == "(a b c)");
   assert(not eq(x1, x2));
 
   let x = circular_list(a, b, c);
diff --git a/test/nan_boxing_pointer.cpp b/test/nan_boxing_pointer.cpp
index f00989c02..f6d390856 100644
--- a/test/nan_boxing_pointer.cpp
+++ b/test/nan_boxing_pointer.cpp
@@ -125,8 +125,8 @@ auto main() -> int
   }
 
   {
-    assert(lexical_cast<std::string>(make<double>(3.14)) == "3.14");
-    assert(lexical_cast<std::string>(make<std::int32_t>(42)) == "42");
+    assert(lexical_cast<external_representation>(make<double>(3.14)) == "3.14");
+    assert(lexical_cast<external_representation>(make<std::int32_t>(42)) == "42");
   }
 
   {

From e0366088768f3fe37a5e3b0dbb5b19b382ca1077 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 03:12:45 +0900
Subject: [PATCH 06/36] Update `vector` to not to inherit `std::vector`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                        |  6 +--
 VERSION                          |  2 +-
 include/meevax/kernel/reader.hpp |  2 +-
 include/meevax/kernel/vector.hpp | 35 ++++++++++----
 src/kernel/library.cpp           | 26 ++++++----
 src/kernel/vector.cpp            | 25 +++-------
 test/vector.cpp                  | 83 ++++++++++++++++----------------
 7 files changed, 96 insertions(+), 83 deletions(-)

diff --git a/README.md b/README.md
index 9cea4ede9..78bface14 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.86.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.87.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.86_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.87_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.86
+Meevax Lisp System, version 0.4.87
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 9cad07ba5..d3391bef6 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.86
+0.4.87
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index b5f42f66e..8768ecf1d 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -394,7 +394,7 @@ inline namespace kernel
 
           case '(':
             is.putback(c);
-            return make<vector>(for_each_in, read(is));
+            return make<vector>(read(is));
 
           case '\\':
             return parse::character(is);
diff --git a/include/meevax/kernel/vector.hpp b/include/meevax/kernel/vector.hpp
index 3fc89e4ee..1359bcd34 100644
--- a/include/meevax/kernel/vector.hpp
+++ b/include/meevax/kernel/vector.hpp
@@ -23,23 +23,38 @@ namespace meevax
 {
 inline namespace kernel
 {
-  enum class for_each_in_tag {} constexpr for_each_in {};
-
-  struct vector : public std::vector<value_type>
+  struct vector
   {
-    using std::vector<meevax::value_type>::vector;
+    std::vector<value_type> data;
+
+    using size_type = decltype(data)::size_type;
+
+    explicit vector() = default;
 
-    template <typename InputIterator>
-    explicit vector(for_each_in_tag, InputIterator from, InputIterator to)
+    /*
+       (vector obj ...)                                               procedure
+
+       Returns a newly allocated vector whose elements contain the given
+       arguments. It is analogous to list.
+    */
+    explicit vector(const_reference x)
     {
-      std::copy(from, to, std::back_inserter(*this));
+      std::copy(std::begin(x), std::end(x), std::back_inserter(data));
     }
 
-    explicit vector(for_each_in_tag, const_reference);
+    /*
+       (make-vector k)                                                procedure
+       (make-vector k fill)                                           procedure
 
-    auto fill(const_reference, size_type, size_type) -> void;
+       Returns a newly allocated vector of k elements. If a second argument is
+       given, then each element is initialized to fill. Otherwise the initial
+       contents of each element is unspecified.
+    */
+    explicit vector(exact_integer const& k, const_reference fill)
+      : data { static_cast<size_type>(k), fill }
+    {}
 
-    auto fill(const_reference, size_type = 0) -> void;
+    auto fill(const_reference, size_type, size_type) -> void;
 
     auto list(size_type, size_type) const -> value_type;
 
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 8e4e68068..1020660c0 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -399,7 +399,7 @@ inline namespace kernel
 
     define<procedure>("list->vector", [](let const& xs)
     {
-      return make<vector>(for_each_in, car(xs));
+      return make<vector>(car(xs));
     });
 
     export_("null?");
@@ -608,7 +608,7 @@ inline namespace kernel
 
     define<procedure>("vector", [](let const& xs)
     {
-      return make<vector>(for_each_in, xs);
+      return make<vector>(xs);
     });
 
     define<procedure>("make-vector", [](let const& xs)
@@ -616,10 +616,10 @@ inline namespace kernel
       switch (length(xs))
       {
       case 1:
-        return make<vector>(static_cast<vector::size_type>(car(xs).as<exact_integer>()), unspecified_object);
+        return make<vector>(car(xs).as<exact_integer>(), unspecified_object);
 
       case 2:
-        return make<vector>(static_cast<vector::size_type>(car(xs).as<exact_integer>()), cadr(xs));
+        return make<vector>(car(xs).as<exact_integer>(), cadr(xs));
 
       default:
         throw invalid_application(intern("make-vector") | xs);
@@ -628,17 +628,17 @@ inline namespace kernel
 
     define<procedure>("vector-length", [](let const& xs)
     {
-      return make<exact_integer>(car(xs).as<vector>().size());
+      return make<exact_integer>(car(xs).as<vector>().data.size());
     });
 
     define<procedure>("vector-ref", [](let const& xs)
     {
-      return car(xs).as<vector>().at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()));
+      return car(xs).as<vector>().data.at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()));
     });
 
     define<procedure>("vector-set!", [](let const& xs)
     {
-      return car(xs).as<vector>().at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>())) = caddr(xs);
+      return car(xs).as<vector>().data.at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>())) = caddr(xs);
     });
 
     define<procedure>("vector-fill!", [](let const& xs)
@@ -646,15 +646,21 @@ inline namespace kernel
       switch (length(xs))
       {
       case 2:
-        car(xs).as<vector>().fill(cadr(xs));
+        car(xs).as<vector>().fill(cadr(xs),
+                                  static_cast<vector::size_type>(caddr(xs).as<exact_integer>()),
+                                  car(xs).as<vector>().data.size()
+                                  );
         break;
 
       case 3:
-        car(xs).as<vector>().fill(cadr(xs), static_cast<string::size_type>(caddr(xs).as<exact_integer>()));
+        car(xs).as<vector>().fill(cadr(xs),
+                                  static_cast<vector::size_type>(caddr(xs).as<exact_integer>()),
+                                  car(xs).as<vector>().data.size()
+                                  );
         break;
 
       case 4:
-        car(xs).as<vector>().fill(cadr(xs), static_cast<string::size_type>(caddr(xs).as<exact_integer>()), static_cast<string::size_type>(cadddr(xs).as<exact_integer>()));
+        car(xs).as<vector>().fill(cadr(xs), static_cast<vector::size_type>(caddr(xs).as<exact_integer>()), static_cast<string::size_type>(cadddr(xs).as<exact_integer>()));
         break;
 
       default:
diff --git a/src/kernel/vector.cpp b/src/kernel/vector.cpp
index a9f5f4685..7af4c5578 100644
--- a/src/kernel/vector.cpp
+++ b/src/kernel/vector.cpp
@@ -23,28 +23,19 @@ namespace meevax
 {
 inline namespace kernel
 {
-  vector::vector(for_each_in_tag, const_reference xs)
-    : vector { for_each_in, std::cbegin(xs), std::cend(xs) }
-  {}
-
   auto vector::fill(const_reference x, size_type from, size_type to) -> void
   {
-    for (auto iter = std::next(begin(), from); iter != std::next(begin(), to); ++iter)
+    for (auto iter = std::next(std::begin(data), from); iter != std::next(std::begin(data), to); ++iter)
     {
       *iter = x;
     }
   }
 
-  auto vector::fill(const_reference x, size_type from) -> void
-  {
-    fill(x, from, size());
-  }
-
   auto vector::list(size_type from, size_type to) const -> value_type
   {
     let x = unit;
 
-    for (auto iter = std::prev(rend(), to); iter != std::prev(rend(), from); ++iter)
+    for (auto iter = std::prev(std::rend(data), to); iter != std::prev(std::rend(data), from); ++iter)
     {
       x = cons(*iter, x);
     }
@@ -54,14 +45,14 @@ inline namespace kernel
 
   auto vector::list(size_type from) const -> value_type
   {
-    return list(from, size());
+    return list(from, std::size(data));
   }
 
   auto vector::string(size_type from, size_type to) const -> value_type
   {
     meevax::string s;
 
-    for (auto iter = std::prev(rend(), to); iter != std::prev(rend(), from); ++iter)
+    for (auto iter = std::prev(std::rend(data), to); iter != std::prev(std::rend(data), from); ++iter)
     {
       if ((*iter).is<character>())
       {
@@ -78,18 +69,18 @@ inline namespace kernel
 
   auto vector::string(size_type from) const -> value_type
   {
-    return string(from, size());
+    return string(from, std::size(data));
   }
 
   auto operator ==(vector const& lhs, vector const& rhs) -> bool
   {
-    return std::equal(std::begin(lhs), std::end(lhs),
-                      std::begin(rhs), std::end(rhs), equal);
+    return std::equal(std::begin(lhs.data), std::end(lhs.data),
+                      std::begin(rhs.data), std::end(rhs.data), equal);
   }
 
   auto operator <<(std::ostream & os, vector const& datum) -> std::ostream &
   {
-    return os << magenta("#(") << for_each(datum) << magenta(")");
+    return os << magenta("#(") << for_each(datum.data) << magenta(")");
   }
 } // namespace kernel
 } // namespace meevax
diff --git a/test/vector.cpp b/test/vector.cpp
index bc367661a..61784d179 100644
--- a/test/vector.cpp
+++ b/test/vector.cpp
@@ -11,36 +11,37 @@ auto main() -> int
 
   // make-vector
   {
-    let const v = make<vector>(make<symbol>("a"),
-                               make<symbol>("b"),
-                               make<symbol>("c"));
+    let const v = make<vector>(list(make<symbol>("a"),
+                                    make<symbol>("b"),
+                                    make<symbol>("c")));
+    gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
-    v.as<vector>().clear();
+    v.as<vector>().data.clear();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 1);
   }
 
@@ -48,36 +49,36 @@ auto main() -> int
 
   // list->vector
   {
-    let const v = make<vector>(for_each_in, list(make<symbol>("a"),
-                                                 make<symbol>("b"),
-                                                 make<symbol>("c")));
+    let const v = make<vector>(list(make<symbol>("a"),
+                                    make<symbol>("b"),
+                                    make<symbol>("c")));
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 7);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
-    v.as<vector>().clear();
+    v.as<vector>().data.clear();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 1);
   }
 
@@ -89,42 +90,42 @@ auto main() -> int
 
     auto const gc_count = gc.count();
 
-    let const v = make<vector>(for_each_in, module.read("(a b c)"));
+    let const v = make<vector>(module.read("(a b c)"));
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
-    assert(v.as<vector>()[0].as<symbol>().value == "a");
-    assert(v.as<vector>()[1].as<symbol>().value == "b");
-    assert(v.as<vector>()[2].as<symbol>().value == "c");
+    assert(v.as<vector>().data.size() == 3);
+    assert(v.as<vector>().data[0].as<symbol>().value == "a");
+    assert(v.as<vector>().data[1].as<symbol>().value == "b");
+    assert(v.as<vector>().data[2].as<symbol>().value == "c");
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
-    assert(v.as<vector>()[0].as<symbol>().value == "a");
-    assert(v.as<vector>()[1].as<symbol>().value == "b");
-    assert(v.as<vector>()[2].as<symbol>().value == "c");
+    assert(v.as<vector>().data.size() == 3);
+    assert(v.as<vector>().data[0].as<symbol>().value == "a");
+    assert(v.as<vector>().data[1].as<symbol>().value == "b");
+    assert(v.as<vector>().data[2].as<symbol>().value == "c");
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
-    assert(v.as<vector>()[0].as<symbol>().value == "a");
-    assert(v.as<vector>()[1].as<symbol>().value == "b");
-    assert(v.as<vector>()[2].as<symbol>().value == "c");
+    assert(v.as<vector>().data.size() == 3);
+    assert(v.as<vector>().data[0].as<symbol>().value == "a");
+    assert(v.as<vector>().data[1].as<symbol>().value == "b");
+    assert(v.as<vector>().data[2].as<symbol>().value == "c");
     assert(gc.count() == gc_count + 4);
 
-    v.as<vector>().clear();
+    v.as<vector>().data.clear();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
   }
 
   environment::symbols.clear();
@@ -139,30 +140,30 @@ auto main() -> int
     let const v = module.read("#(a b c)");
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 3);
+    assert(v.as<vector>().data.size() == 3);
     assert(gc.count() == gc_count + 4);
 
-    v.as<vector>().clear();
+    v.as<vector>().data.clear();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 4);
 
     gc.collect();
 
     assert(v.is<vector>());
-    assert(v.as<vector>().size() == 0);
+    assert(v.as<vector>().data.size() == 0);
     assert(gc.count() == gc_count + 4);
   }
 
@@ -175,7 +176,7 @@ auto main() -> int
 
     module.define<procedure>("vector", [](let const& xs)
     {
-      return make<vector>(for_each_in, xs);
+      return make<vector>(xs);
     });
 
     module.evaluate(module.read("(vector 1 2 3)"));

From 5e66ebfd2bf9e342a418b36fe621bcb626415342 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 30 Jun 2022 23:50:30 +0900
Subject: [PATCH 07/36] Cleanup `vector` implementation

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                               |  6 +-
 VERSION                                 |  2 +-
 include/meevax/kernel/exact_integer.hpp |  6 +-
 include/meevax/kernel/vector.hpp        | 78 +++++++++++++++++++++----
 src/kernel/library.cpp                  | 34 +++++------
 src/kernel/vector.cpp                   | 66 +++++++++++----------
 test/r7rs.ss                            |  4 +-
 7 files changed, 124 insertions(+), 72 deletions(-)

diff --git a/README.md b/README.md
index 78bface14..053142b8b 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.87.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.88.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.87_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.88_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.87
+Meevax Lisp System, version 0.4.88
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index d3391bef6..f454e1a97 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.87
+0.4.88
diff --git a/include/meevax/kernel/exact_integer.hpp b/include/meevax/kernel/exact_integer.hpp
index ccf778d3a..796d11884 100644
--- a/include/meevax/kernel/exact_integer.hpp
+++ b/include/meevax/kernel/exact_integer.hpp
@@ -104,11 +104,11 @@ inline namespace kernel
 
     explicit operator bool() const;
 
-    explicit operator int() const;
+    operator int() const;
 
-    explicit operator signed long() const;
+    operator signed long() const;
 
-    explicit operator unsigned long() const;
+    operator unsigned long() const;
 
     explicit operator float() const;
 
diff --git a/include/meevax/kernel/vector.hpp b/include/meevax/kernel/vector.hpp
index 1359bcd34..b8d5e483d 100644
--- a/include/meevax/kernel/vector.hpp
+++ b/include/meevax/kernel/vector.hpp
@@ -37,10 +37,7 @@ inline namespace kernel
        Returns a newly allocated vector whose elements contain the given
        arguments. It is analogous to list.
     */
-    explicit vector(const_reference x)
-    {
-      std::copy(std::begin(x), std::end(x), std::back_inserter(data));
-    }
+    explicit vector(const_reference);
 
     /*
        (make-vector k)                                                procedure
@@ -50,19 +47,76 @@ inline namespace kernel
        given, then each element is initialized to fill. Otherwise the initial
        contents of each element is unspecified.
     */
-    explicit vector(exact_integer const& k, const_reference fill)
-      : data { static_cast<size_type>(k), fill }
-    {}
+    explicit vector(const_reference, const_reference);
 
-    auto fill(const_reference, size_type, size_type) -> void;
+    /*
+       (vector-fill! vector fill)                                     procedure
+       (vector-fill! vector fill start)                               procedure
+       (vector-fill! vector fill start end)                           procedure
+
+       The vector-fill! procedure stores fill in the elements of vector between
+       start and end.
+    */
+    auto fill(const_reference, const_reference, const_reference) -> void;
+
+    /*
+       (vector-length vector)                                         procedure
+
+       Returns the number of elements in vector as an exact integer.
+    */
+    auto length() const -> value_type;
+
+    /*
+       (vector->list vector)                                          procedure
+       (vector->list vector start)                                    procedure
+       (vector->list vector start end)                                procedure
+       (list->vector list)                                            procedure
 
-    auto list(size_type, size_type) const -> value_type;
+       The vector->list procedure returns a newly allocated list of the objects
+       contained in the elements of vector between start and end. The
+       list->vector procedure returns a newly created vector initialized to the
+       elements of the list list.
 
-    auto list(size_type = 0) const -> value_type;
+       In both procedures, order is preserved.
+    */
+    auto list(const_reference, const_reference) const -> value_type;
 
-    auto string(size_type, size_type) const -> value_type;
+    /*
+       (vector-ref vector k)                                          procedure
 
-    auto string(size_type = 0) const -> value_type;
+       It is an error if k is not a valid index of vector. The vector-ref
+       procedure returns the contents of element k of vector.
+    */
+    auto ref(const_reference) const -> const_reference;
+
+    /*
+       (vector-set! vector k obj)                                     procedure
+
+       It is an error if k is not a valid index of vector. The vector-set!
+       procedure stores obj in element k of vector.
+    */
+    auto set(const_reference, const_reference) -> const_reference;
+
+    /*
+       (vector->string vector)                                        procedure
+       (vector->string vector start)                                  procedure
+       (vector->string vector start end)                              procedure
+
+       (string->vector string)                                        procedure
+       (string->vector string start)                                  procedure
+       (string->vector string start end)                              procedure
+
+       It is an error if any element of vector between start and end is not a
+       character.
+
+       The vector->string procedure returns a newly allocated string of the
+       objects contained in the elements of vector between start and end. The
+       string->vector procedure returns a newly created vector initialized to
+       the elements of the string string between start and end.
+
+       In both procedures, order is preserved.
+    */
+    auto string(const_reference, const_reference) const -> value_type;
   };
 
   auto operator ==(vector const&, vector const&) -> bool;
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 1020660c0..adc667a72 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -616,10 +616,10 @@ inline namespace kernel
       switch (length(xs))
       {
       case 1:
-        return make<vector>(car(xs).as<exact_integer>(), unspecified_object);
+        return make<vector>(car(xs), unspecified_object);
 
       case 2:
-        return make<vector>(car(xs).as<exact_integer>(), cadr(xs));
+        return make<vector>(car(xs), cadr(xs));
 
       default:
         throw invalid_application(intern("make-vector") | xs);
@@ -628,17 +628,17 @@ inline namespace kernel
 
     define<procedure>("vector-length", [](let const& xs)
     {
-      return make<exact_integer>(car(xs).as<vector>().data.size());
+      return car(xs).as<vector>().length();
     });
 
     define<procedure>("vector-ref", [](let const& xs)
     {
-      return car(xs).as<vector>().data.at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()));
+      return car(xs).as<vector>().ref(cadr(xs));
     });
 
     define<procedure>("vector-set!", [](let const& xs)
     {
-      return car(xs).as<vector>().data.at(static_cast<vector::size_type>(cadr(xs).as<exact_integer>())) = caddr(xs);
+      return car(xs).as<vector>().set(cadr(xs), caddr(xs));
     });
 
     define<procedure>("vector-fill!", [](let const& xs)
@@ -646,21 +646,15 @@ inline namespace kernel
       switch (length(xs))
       {
       case 2:
-        car(xs).as<vector>().fill(cadr(xs),
-                                  static_cast<vector::size_type>(caddr(xs).as<exact_integer>()),
-                                  car(xs).as<vector>().data.size()
-                                  );
+        car(xs).as<vector>().fill(cadr(xs), e0, car(xs).as<vector>().length());
         break;
 
       case 3:
-        car(xs).as<vector>().fill(cadr(xs),
-                                  static_cast<vector::size_type>(caddr(xs).as<exact_integer>()),
-                                  car(xs).as<vector>().data.size()
-                                  );
+        car(xs).as<vector>().fill(cadr(xs), caddr(xs), car(xs).as<vector>().length());
         break;
 
       case 4:
-        car(xs).as<vector>().fill(cadr(xs), static_cast<vector::size_type>(caddr(xs).as<exact_integer>()), static_cast<string::size_type>(cadddr(xs).as<exact_integer>()));
+        car(xs).as<vector>().fill(cadr(xs), caddr(xs), cadddr(xs));
         break;
 
       default:
@@ -675,13 +669,13 @@ inline namespace kernel
       switch (length(xs))
       {
       case 1:
-        return car(xs).as<vector>().list();
+        return car(xs).as<vector>().list(e0, car(xs).as<vector>().length());
 
       case 2:
-        return car(xs).as<vector>().list(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()));
+        return car(xs).as<vector>().list(cadr(xs), car(xs).as<vector>().length());
 
       case 3:
-        return car(xs).as<vector>().list(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()), static_cast<vector::size_type>(caddr(xs).as<exact_integer>()));
+        return car(xs).as<vector>().list(cadr(xs), caddr(xs));
 
       default:
         throw invalid_application(intern("vector->list") | xs);
@@ -693,13 +687,13 @@ inline namespace kernel
       switch (length(xs))
       {
       case 1:
-        return car(xs).as<vector>().string();
+        return car(xs).as<vector>().string(e0, car(xs).as<vector>().length());
 
       case 2:
-        return car(xs).as<vector>().string(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()));
+        return car(xs).as<vector>().string(cadr(xs), car(xs).as<vector>().length());
 
       case 3:
-        return car(xs).as<vector>().string(static_cast<vector::size_type>(cadr(xs).as<exact_integer>()), static_cast<vector::size_type>(caddr(xs).as<exact_integer>()));
+        return car(xs).as<vector>().string(cadr(xs), caddr(xs));
 
       default:
         throw invalid_application(intern("vector->string") | xs);
diff --git a/src/kernel/vector.cpp b/src/kernel/vector.cpp
index 7af4c5578..4e4c019fb 100644
--- a/src/kernel/vector.cpp
+++ b/src/kernel/vector.cpp
@@ -23,55 +23,59 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto vector::fill(const_reference x, size_type from, size_type to) -> void
+  vector::vector(const_reference x)
   {
-    for (auto iter = std::next(std::begin(data), from); iter != std::next(std::begin(data), to); ++iter)
-    {
-      *iter = x;
-    }
+    std::copy(std::begin(x), std::end(x), std::back_inserter(data));
   }
 
-  auto vector::list(size_type from, size_type to) const -> value_type
+  vector::vector(const_reference k, const_reference fill)
+    : data { k.as<exact_integer>(), fill }
+  {}
+
+  auto vector::fill(const_reference x, const_reference from, const_reference to) -> void
   {
-    let x = unit;
+    std::fill(std::next(std::begin(data), from.as<exact_integer>()),
+              std::next(std::begin(data), to.as<exact_integer>()),
+              x);
+  }
 
-    for (auto iter = std::prev(std::rend(data), to); iter != std::prev(std::rend(data), from); ++iter)
-    {
-      x = cons(*iter, x);
-    }
+  auto vector::length() const -> value_type
+  {
+    return make<exact_integer>(data.size());
+  }
 
-    return x;
+  auto vector::list(const_reference from, const_reference to) const -> value_type
+  {
+    return std::accumulate(std::prev(std::rend(data), to.as<exact_integer>()),
+                           std::prev(std::rend(data), from.as<exact_integer>()),
+                           unit,
+                           xcons);
   }
 
-  auto vector::list(size_type from) const -> value_type
+  auto vector::ref(const_reference k) const -> const_reference
   {
-    return list(from, std::size(data));
+    return data.at(k.as<exact_integer>());
   }
 
-  auto vector::string(size_type from, size_type to) const -> value_type
+  auto vector::set(const_reference k, const_reference x) -> const_reference
+  {
+    return data.at(k.as<exact_integer>()) = x;
+  }
+
+  auto vector::string(const_reference from, const_reference to) const -> value_type
   {
     meevax::string s;
 
-    for (auto iter = std::prev(std::rend(data), to); iter != std::prev(std::rend(data), from); ++iter)
-    {
-      if ((*iter).is<character>())
-      {
-        s.push_back((*iter).as<character>());
-      }
-      else
-      {
-        throw error(make<meevax::string>("It is an error if any element of vector between start and end is not a character"), unit);
-      }
-    }
+    std::for_each(std::next(std::begin(data), from.as<exact_integer>()),
+                  std::next(std::begin(data), to.as<exact_integer>()),
+                  [&](let const& each)
+                  {
+                    s.push_back(each.as<character>());
+                  });
 
     return make(s);
   }
 
-  auto vector::string(size_type from) const -> value_type
-  {
-    return string(from, std::size(data));
-  }
-
   auto operator ==(vector const& lhs, vector const& rhs) -> bool
   {
     return std::equal(std::begin(lhs.data), std::end(lhs.data),
diff --git a/test/r7rs.ss b/test/r7rs.ss
index d09eda3d2..bfa1273e5 100644
--- a/test/r7rs.ss
+++ b/test/r7rs.ss
@@ -971,7 +971,7 @@
 (check (list->vector '(dididit dah)) => #(dididit dah))
 
 ; (check (string->vector "ABC") => #(#\A #\B #\C))
-; (check (vector->string #(#\1 #\2 #\3) => "123"))
+(check (vector->string #(#\1 #\2 #\3)) => "123")
 
 ; (define a #(1 8 2 8)) ; a may be immutable
 ; (define b (vector-copy a))
@@ -1197,4 +1197,4 @@
 
 (check-report)
 
-(exit (check-passed? 367))
+(exit (check-passed? 368))

From 8c73794c92e355c3eea63a623ef62c532fb4f49d Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Fri, 1 Jul 2022 00:16:31 +0900
Subject: [PATCH 08/36] Add new type `ghost`

---
 README.md                              |  6 +++---
 VERSION                                |  2 +-
 example/example.cpp                    |  2 +-
 include/meevax/kernel/complex.hpp      | 14 +++++++-------
 include/meevax/kernel/configurator.hpp | 10 +++++-----
 include/meevax/kernel/ghost.hpp        | 12 +++++++-----
 include/meevax/kernel/machine.hpp      |  6 +++---
 src/kernel/environment.cpp             |  4 ++--
 src/kernel/ghost.cpp                   |  6 +++---
 src/kernel/library.cpp                 | 16 ++++++++--------
 test/environment.cpp                   |  2 +-
 11 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/README.md b/README.md
index 053142b8b..0b315e173 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.88.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.89.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.88_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.89_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.88
+Meevax Lisp System, version 0.4.89
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index f454e1a97..fb6d83681 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.88
+0.4.89
diff --git a/example/example.cpp b/example/example.cpp
index 20cca0a09..ef56ef494 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -32,6 +32,6 @@ extern "C"
       }
     }
 
-    return unspecified_object;
+    return unspecified;
   }
 }
diff --git a/include/meevax/kernel/complex.hpp b/include/meevax/kernel/complex.hpp
index c75d3cd81..246eedd17 100644
--- a/include/meevax/kernel/complex.hpp
+++ b/include/meevax/kernel/complex.hpp
@@ -40,7 +40,7 @@ inline namespace kernel
     #define DEFINE(NAME)                                                       \
     auto NAME() const -> value_type override                                   \
     {                                                                          \
-      return unspecified_object;                                               \
+      return unspecified;                                                      \
     }                                                                          \
     static_assert(true)
 
@@ -57,7 +57,7 @@ inline namespace kernel
     #define DEFINE(NAME)                                                       \
     auto NAME(const_reference) const -> value_type override                    \
     {                                                                          \
-      return unspecified_object;                                               \
+      return unspecified;                                                      \
     }                                                                          \
     static_assert(true)
 
@@ -66,11 +66,11 @@ inline namespace kernel
 
     #undef DEFINE
 
-    auto operator + (const_reference) const -> value_type override { return unspecified_object; }
-    auto operator - (const_reference) const -> value_type override { return unspecified_object; }
-    auto operator * (const_reference) const -> value_type override { return unspecified_object; }
-    auto operator / (const_reference) const -> value_type override { return unspecified_object; }
-    auto operator % (const_reference) const -> value_type override { return unspecified_object; }
+    auto operator + (const_reference) const -> value_type override { return unspecified; }
+    auto operator - (const_reference) const -> value_type override { return unspecified; }
+    auto operator * (const_reference) const -> value_type override { return unspecified; }
+    auto operator / (const_reference) const -> value_type override { return unspecified; }
+    auto operator % (const_reference) const -> value_type override { return unspecified; }
 
     auto operator ==(const_reference) const -> bool override { return false; };
     auto operator !=(const_reference) const -> bool override { return false; };
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index 705c4ca7a..d9b2496c2 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -113,7 +113,7 @@ inline namespace kernel
       std::make_pair('e', [](const_reference x, auto&&...)
       {
         print(interaction_environment().as<environment>().evaluate(x));
-        return unspecified_object;
+        return unspecified;
       }),
 
       std::make_pair('l', [](const_reference x, auto&&...)
@@ -124,7 +124,7 @@ inline namespace kernel
       std::make_pair('w', [](const_reference x, auto&&...)
       {
         print(x);
-        return unspecified_object;
+        return unspecified;
       }),
     };
 
@@ -173,7 +173,7 @@ inline namespace kernel
       std::make_pair("evaluate", [](const_reference x, auto&&...)
       {
         print(interaction_environment().as<environment>().evaluate(x));
-        return unspecified_object;
+        return unspecified;
       }),
 
       std::make_pair("load", [](const_reference x, auto&&...)
@@ -184,7 +184,7 @@ inline namespace kernel
       std::make_pair("write", [](const_reference x, auto&&...)
       {
         print(x);
-        return unspecified_object;
+        return unspecified;
       }),
     };
 
@@ -273,7 +273,7 @@ inline namespace kernel
           return load(*current_option);
         }
 
-        return unspecified_object;
+        return unspecified;
       }();
     }
   };
diff --git a/include/meevax/kernel/ghost.hpp b/include/meevax/kernel/ghost.hpp
index 1c96ee89d..18ee90c75 100644
--- a/include/meevax/kernel/ghost.hpp
+++ b/include/meevax/kernel/ghost.hpp
@@ -23,19 +23,21 @@ namespace meevax
 {
 inline namespace kernel
 {
-  struct unspecified
-  {};
+  struct ghost
+  {
+    external_representation const name = "unspecified";
+  };
 
-  auto operator <<(std::ostream &, unspecified const&) -> std::ostream &;
+  auto operator <<(std::ostream &, ghost const&) -> std::ostream &;
 
-  extern let const unspecified_object;
+  let extern const unspecified;
 
   struct unbound
   {};
 
   auto operator <<(std::ostream &, unbound const&) -> std::ostream &;
 
-  extern let const undefined;
+  let extern const undefined;
 } // namespace kernel
 } // namespace meevax
 
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 620fd0a1a..4b7f1e155 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -909,7 +909,7 @@ inline namespace kernel
                                         caddr(current_expression),
                                         current_scope,
                                         current_continuation)
-                              : list(make(mnemonic::load_constant), unspecified_object,
+                              : list(make(mnemonic::load_constant), unspecified,
                                      make(mnemonic::return_))));
       }
       else
@@ -930,7 +930,7 @@ inline namespace kernel
                                         caddr(current_expression),
                                         current_scope,
                                         list(make(mnemonic::join)))
-                              : list(make(mnemonic::load_constant), unspecified_object,
+                              : list(make(mnemonic::load_constant), unspecified,
                                      make(mnemonic::join)),
                             current_continuation));
       }
@@ -989,7 +989,7 @@ inline namespace kernel
         {
           return compile(context(),
                          current_environment,
-                         cdr(current_expression) ? cadr(current_expression) : unspecified_object,
+                         cdr(current_expression) ? cadr(current_expression) : unspecified,
                          current_scope,
                          cons(make(mnemonic::define), current_environment.identify(car(current_expression), current_scope),
                               current_continuation));
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 0a7c2effb..59f5d67eb 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -79,7 +79,7 @@ inline namespace kernel
         import_(import_set);
       }
 
-      return unspecified_object;
+      return unspecified;
     }
     else
     {
@@ -185,7 +185,7 @@ inline namespace kernel
         evaluate(e);
       }
 
-      return unspecified_object;
+      return unspecified;
     }
     else
     {
diff --git a/src/kernel/ghost.cpp b/src/kernel/ghost.cpp
index c08ab9225..733609368 100644
--- a/src/kernel/ghost.cpp
+++ b/src/kernel/ghost.cpp
@@ -20,12 +20,12 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto operator <<(std::ostream & os, unspecified const&) -> std::ostream &
+  auto operator <<(std::ostream & os, ghost const& ghost) -> std::ostream &
   {
-    return os << faint("#;unspecified");
+    return os << faint("#;", ghost.name);
   }
 
-  let const unspecified_object = make<unspecified>();
+  let const unspecified = make<ghost>("unspecified");
 
   auto operator <<(std::ostream & os, unbound const&) -> std::ostream &
   {
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index adc667a72..d9f3a2089 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -616,7 +616,7 @@ inline namespace kernel
       switch (length(xs))
       {
       case 1:
-        return make<vector>(car(xs), unspecified_object);
+        return make<vector>(car(xs), unspecified);
 
       case 2:
         return make<vector>(car(xs), cadr(xs));
@@ -661,7 +661,7 @@ inline namespace kernel
         throw invalid_application(intern("vector-fill!") | xs);
       }
 
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("vector->list", [](let const& xs)
@@ -813,7 +813,7 @@ inline namespace kernel
         x.as<std::ifstream>().close();
       }
 
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("close-output-port", [](let const& xs)
@@ -823,7 +823,7 @@ inline namespace kernel
         x.as<std::ofstream>().close();
       }
 
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("open-input-string", [](let const& xs)
@@ -926,7 +926,7 @@ inline namespace kernel
     define<procedure>("put-char", [](let const& xs)
     {
       cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<character>());
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("put-string", [](let const& xs)
@@ -944,13 +944,13 @@ inline namespace kernel
         throw invalid_application(intern("write-string") | xs);
       }
 
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("%flush-output-port", [](let const& xs)
     {
       car(xs).as<std::ostream>() << std::flush;
-      return unspecified_object;
+      return unspecified;
     });
 
     export_("input-port?");
@@ -1017,7 +1017,7 @@ inline namespace kernel
     define<procedure>("%write-simple", [](let const& xs)
     {
       write(cadr(xs), car(xs));
-      return unspecified_object;
+      return unspecified;
     });
 
     define<procedure>("print", [](let const& xs)
diff --git a/test/environment.cpp b/test/environment.cpp
index 9311f076c..58ea41037 100644
--- a/test/environment.cpp
+++ b/test/environment.cpp
@@ -17,7 +17,7 @@ auto main() -> int
     assert(e1.is<exact_integer>());
     assert(eof_object.is<eof>());
     assert(undefined.is<unbound>());
-    assert(unspecified_object.is<unspecified>());
+    assert(unspecified.is<ghost>());
     assert(interaction_environment().is<environment>());
   }
 

From cb4cd970afca1ab26ec5c3f43b79169418d1ace2 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Fri, 1 Jul 2022 01:33:04 +0900
Subject: [PATCH 09/36] Cleanup `car` and `cdr`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |  6 +++---
 VERSION                           |  2 +-
 include/meevax/kernel/list.hpp    | 21 ++++++++++-----------
 include/meevax/kernel/machine.hpp |  2 +-
 include/meevax/kernel/pair.hpp    |  2 +-
 src/kernel/iterator.cpp           |  2 +-
 src/kernel/pair.cpp               |  2 +-
 7 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index 0b315e173..f1ffcb2ce 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.89.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.90.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.89_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.90_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.89
+Meevax Lisp System, version 0.4.90
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index fb6d83681..d881a037a 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.89
+0.4.90
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 0b490e73b..92cd7644f 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -28,32 +28,31 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto unwrap = [](auto&& x) -> decltype(auto)
+  template <auto N, typename T>
+  auto field(T&& x) -> decltype(auto)
   {
-    using type = typename std::decay<decltype(x)>::type;
-
-    if constexpr (std::is_same<type, iterator>::value)
+    if constexpr (std::is_same_v<std::decay_t<decltype(x)>, iterator>)
     {
-      return x.get().template as<pair>();
+      return std::get<N>(x.get().template as<pair>());
     }
-    else if constexpr (std::is_same<type, value_type>::value)
+    else if constexpr (std::is_same_v<std::decay_t<decltype(x)>, value_type>)
     {
-      return x.template as<pair>();
+      return std::get<N>(x.template as<pair>());
     }
     else
     {
-      return std::forward<decltype(x)>(x);
+      return std::get<N>(x);
     }
-  };
+  }
 
   auto car = [](auto&& x) -> decltype(auto)
   {
-    return std::get<0>(unwrap(std::forward<decltype(x)>(x)));
+    return field<0>(std::forward<decltype(x)>(x));
   };
 
   auto cdr = [](auto&& x) -> decltype(auto)
   {
-    return std::get<1>(unwrap(std::forward<decltype(x)>(x)));
+    return field<1>(std::forward<decltype(x)>(x));
   };
 
   template <typename T, typename U, REQUIRES(std::is_convertible<T, value_type>,
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 4b7f1e155..b61098a4e 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -837,7 +837,7 @@ inline namespace kernel
                                              },
                                              binding_specs),
                                          body)),
-                            make_list(length(binding_specs), undefined)),
+                            make_list(length(binding_specs), unit)),
                        current_scope,
                        current_continuation);
       }
diff --git a/include/meevax/kernel/pair.hpp b/include/meevax/kernel/pair.hpp
index d2a11a1d0..8fc2e7386 100644
--- a/include/meevax/kernel/pair.hpp
+++ b/include/meevax/kernel/pair.hpp
@@ -23,7 +23,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  let extern const unit;
+  let extern unit;
 
   template <typename T>
   using pair_of = std::pair<T, T>;
diff --git a/src/kernel/iterator.cpp b/src/kernel/iterator.cpp
index d36db6786..4ab50b543 100644
--- a/src/kernel/iterator.cpp
+++ b/src/kernel/iterator.cpp
@@ -27,7 +27,7 @@ inline namespace kernel
 
   auto iterator::operator ->() const -> iterator::pointer
   {
-    return std::addressof(car(*this));
+    return &car(*this);
   }
 
   auto iterator::operator ++() -> iterator &
diff --git a/src/kernel/pair.cpp b/src/kernel/pair.cpp
index 547588507..d4c801458 100644
--- a/src/kernel/pair.cpp
+++ b/src/kernel/pair.cpp
@@ -20,7 +20,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  let const unit { nullptr };
+  let unit { nullptr };
 
   auto operator <<(std::ostream & os, pair const& pare) -> std::ostream &
   {

From 697afb675f569de6e0f75a2d8132d422d1ce26b6 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Fri, 1 Jul 2022 19:30:50 +0900
Subject: [PATCH 10/36] Update `car` and `cdr` to return empty-list if
 empty-list given

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                      | 6 +++---
 VERSION                        | 2 +-
 include/meevax/kernel/list.hpp | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index f1ffcb2ce..b0a30138b 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.90.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.91.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.90_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.91_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.90
+Meevax Lisp System, version 0.4.91
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index d881a037a..30f1d8d74 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.90
+0.4.91
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 92cd7644f..aa018d5b2 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -37,7 +37,7 @@ inline namespace kernel
     }
     else if constexpr (std::is_same_v<std::decay_t<decltype(x)>, value_type>)
     {
-      return std::get<N>(x.template as<pair>());
+      return x.template is<null>() ? unit : std::get<N>(x.template as<pair>());
     }
     else
     {

From 2d536e24899ee85bd90b9ee1913ccd495a852691 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 3 Jul 2022 12:28:07 +0900
Subject: [PATCH 11/36] Remove type `unbound`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                       | 6 +++---
 VERSION                         | 2 +-
 include/meevax/kernel/ghost.hpp | 7 +------
 src/kernel/ghost.cpp            | 7 +------
 src/kernel/identity.cpp         | 2 +-
 test/environment.cpp            | 2 +-
 6 files changed, 8 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index b0a30138b..df9a9a5cf 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.91.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.92.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.91_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.92_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.91
+Meevax Lisp System, version 0.4.92
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 30f1d8d74..bad3afd3b 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.91
+0.4.92
diff --git a/include/meevax/kernel/ghost.hpp b/include/meevax/kernel/ghost.hpp
index 18ee90c75..84295706f 100644
--- a/include/meevax/kernel/ghost.hpp
+++ b/include/meevax/kernel/ghost.hpp
@@ -25,18 +25,13 @@ inline namespace kernel
 {
   struct ghost
   {
-    external_representation const name = "unspecified";
+    external_representation const name;
   };
 
   auto operator <<(std::ostream &, ghost const&) -> std::ostream &;
 
   let extern const unspecified;
 
-  struct unbound
-  {};
-
-  auto operator <<(std::ostream &, unbound const&) -> std::ostream &;
-
   let extern const undefined;
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/ghost.cpp b/src/kernel/ghost.cpp
index 733609368..6fc496fa1 100644
--- a/src/kernel/ghost.cpp
+++ b/src/kernel/ghost.cpp
@@ -27,11 +27,6 @@ inline namespace kernel
 
   let const unspecified = make<ghost>("unspecified");
 
-  auto operator <<(std::ostream & os, unbound const&) -> std::ostream &
-  {
-    return os << faint("#;unbound");
-  }
-
-  let const undefined = make<unbound>();
+  let const undefined = make<ghost>("undefined");
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/identity.cpp b/src/kernel/identity.cpp
index 554d3c978..b73f3cf7f 100644
--- a/src/kernel/identity.cpp
+++ b/src/kernel/identity.cpp
@@ -47,7 +47,7 @@ inline namespace kernel
 
   auto absolute::is_free() const -> bool
   {
-    return load().is<unbound>();
+    return eq(load(), undefined);
   }
 
   auto absolute::load(const_reference) const -> const_reference
diff --git a/test/environment.cpp b/test/environment.cpp
index 58ea41037..bb0c2e311 100644
--- a/test/environment.cpp
+++ b/test/environment.cpp
@@ -16,7 +16,7 @@ auto main() -> int
     assert(e0.is<exact_integer>());
     assert(e1.is<exact_integer>());
     assert(eof_object.is<eof>());
-    assert(undefined.is<unbound>());
+    assert(undefined.is<ghost>());
     assert(unspecified.is<ghost>());
     assert(interaction_environment().is<environment>());
   }

From 9e217cc40f09c470b8dc8d51a4158c357a8bf553 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 3 Jul 2022 14:34:45 +0900
Subject: [PATCH 12/36] Update `heterogeneous` to accept non-output-streamable
 type

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                                     |  6 +--
 VERSION                                       |  2 +-
 example/example.cpp                           | 25 +++++++++++
 example/example.ss                            | 43 +++++++++++++++++--
 include/meevax/kernel/error.hpp               |  1 +
 include/meevax/kernel/heterogeneous.hpp       | 10 ++++-
 .../meevax/type_traits/is_dereferenceable.hpp | 16 +++++++
 .../type_traits/is_output_streamable.hpp      | 38 ++++++++++++++++
 8 files changed, 132 insertions(+), 9 deletions(-)
 create mode 100644 include/meevax/type_traits/is_output_streamable.hpp

diff --git a/README.md b/README.md
index df9a9a5cf..86da2d205 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.92.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.93.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.92_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.93_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.92
+Meevax Lisp System, version 0.4.93
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index bad3afd3b..e9bcc870b 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.92
+0.4.93
diff --git a/example/example.cpp b/example/example.cpp
index ef56ef494..ad4d42605 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -34,4 +34,29 @@ extern "C"
 
     return unspecified;
   }
+
+  struct hoge
+  {
+    int value;
+
+    ~hoge()
+    {
+      std::cout << "DESTRUCTOR!" << std::endl;
+    }
+  };
+
+  let make_hoge(let const& xs)
+  {
+    return make<hoge>(car(xs).as<exact_integer>());
+  }
+
+  let is_hoge(let const& xs)
+  {
+    return car(xs).is<hoge>() ? t : f;
+  }
+
+  let hoge_value(let const& xs)
+  {
+    return make<exact_integer>(car(xs).as<hoge>().value);
+  }
 }
diff --git a/example/example.ss b/example/example.ss
index c1f39dee0..e13f764d4 100644
--- a/example/example.ss
+++ b/example/example.ss
@@ -1,16 +1,51 @@
 (import (meevax foreign-function)
         (scheme base)
-        (only (scheme process-context) exit)
+        (scheme process-context)
+        (scheme write)
         (srfi 78))
 
-(define dummy-procedure (foreign-function "build/libexample.so" "dummy_procedure"))
+; ------------------------------------------------------------------------------
+
+(define dummy-procedure
+  (foreign-function "build/libexample.so" "dummy_procedure"))
 
 (check (foreign-function? dummy-procedure) => #t)
+
 (check (dummy-procedure 'hoge 42 #(1 2 3) 3.14) => 43)
 
-(define length-of-arguments (foreign-function "build/libexample.so" "length_of_arguments"))
+; ------------------------------------------------------------------------------
+
+(define length-of-arguments
+  (foreign-function "build/libexample.so" "length_of_arguments"))
 
 (check (foreign-function? length-of-arguments) => #t)
+
 (check (length-of-arguments 'hoge 42 #(1 2 3) 3.14) => 4)
 
-(exit (check-passed? 4))
+; ------------------------------------------------------------------------------
+
+(define make-hoge
+  (foreign-function "build/libexample.so" "make_hoge"))
+
+(define hoge?
+  (foreign-function "build/libexample.so" "is_hoge"))
+
+(define hoge-value
+  (foreign-function "build/libexample.so" "hoge_value"))
+
+(check (foreign-function? make-hoge) => #t)
+
+(check (foreign-function? hoge?) => #t)
+
+(check (foreign-function? hoge-value) => #t)
+
+(define h (make-hoge 100))
+
+(display h)
+(newline)
+
+(check (hoge? h) => #t)
+
+(check (hoge-value h) => 100)
+
+(exit (check-passed? 9))
diff --git a/include/meevax/kernel/error.hpp b/include/meevax/kernel/error.hpp
index ff421182b..155d6efca 100644
--- a/include/meevax/kernel/error.hpp
+++ b/include/meevax/kernel/error.hpp
@@ -79,6 +79,7 @@ inline namespace kernel
 
     catch (exit_status const value) // NOTE: emergency-exit
     {
+      gc.clear(); // NOTE:
       return underlying_cast(value);
     }
 
diff --git a/include/meevax/kernel/heterogeneous.hpp b/include/meevax/kernel/heterogeneous.hpp
index 916b3042c..c609f3e70 100644
--- a/include/meevax/kernel/heterogeneous.hpp
+++ b/include/meevax/kernel/heterogeneous.hpp
@@ -23,6 +23,7 @@
 #include <meevax/kernel/overview.hpp>
 #include <meevax/kernel/profiler.hpp>
 #include <meevax/type_traits/is_equality_comparable.hpp>
+#include <meevax/type_traits/is_output_streamable.hpp>
 #include <meevax/utility/module.hpp>
 
 namespace meevax
@@ -69,7 +70,14 @@ inline namespace kernel
 
       auto write(std::ostream & os) const -> std::ostream & override
       {
-        return os << static_cast<Bound const&>(*this);
+        if constexpr (is_output_streamable<Bound>::value)
+        {
+          return os << static_cast<Bound const&>(*this);
+        }
+        else
+        {
+          return os << magenta("#,(") << green(typeid(Bound).name()) << faint(" #;", static_cast<Bound const*>(this)) << magenta(")");
+        }
       }
     };
 
diff --git a/include/meevax/type_traits/is_dereferenceable.hpp b/include/meevax/type_traits/is_dereferenceable.hpp
index ae40e2642..3e33bfba9 100644
--- a/include/meevax/type_traits/is_dereferenceable.hpp
+++ b/include/meevax/type_traits/is_dereferenceable.hpp
@@ -1,3 +1,19 @@
+/*
+   Copyright 2018-2022 Tatsuya Yamasaki.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
 #ifndef INCLUDED_MEEVAX_TYPE_TRAITS_IS_DEREFERENCEABLE_HPP
 #define INCLUDED_MEEVAX_TYPE_TRAITS_IS_DEREFERENCEABLE_HPP
 
diff --git a/include/meevax/type_traits/is_output_streamable.hpp b/include/meevax/type_traits/is_output_streamable.hpp
new file mode 100644
index 000000000..ee27c170e
--- /dev/null
+++ b/include/meevax/type_traits/is_output_streamable.hpp
@@ -0,0 +1,38 @@
+/*
+   Copyright 2018-2022 Tatsuya Yamasaki.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+#ifndef INCLUDED_MEEVAX_TYPE_TRAITS_IS_OUTPUT_STREAMABLE_HPP
+#define INCLUDED_MEEVAX_TYPE_TRAITS_IS_OUTPUT_STREAMABLE_HPP
+
+#include <ostream>
+#include <type_traits>
+
+namespace meevax
+{
+inline namespace type_traits
+{
+  template <typename T, typename = void>
+  struct is_output_streamable : public std::false_type
+  {};
+
+  template <typename T>
+  struct is_output_streamable<T, std::void_t<decltype(std::declval<std::ostream &>() << std::declval<T>())>>
+    : public std::true_type
+  {};
+} // namespace type_traits
+} // namespace meevax
+
+#endif // INCLUDED_MEEVAX_TYPE_TRAITS_IS_OUTPUT_STREAMABLE_HPP

From d7c63722a9076c4c650c0d0da132913cce2bfdf2 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 3 Jul 2022 14:52:13 +0900
Subject: [PATCH 13/36] Remove struct `deallocator`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 ++---
 VERSION                               |  2 +-
 include/meevax/memory/collector.hpp   |  5 +++-
 include/meevax/memory/deallocator.hpp | 39 ---------------------------
 include/meevax/memory/tracer.hpp      |  9 +++----
 src/memory/tracer.cpp                 |  4 +--
 6 files changed, 13 insertions(+), 52 deletions(-)
 delete mode 100644 include/meevax/memory/deallocator.hpp

diff --git a/README.md b/README.md
index 86da2d205..f8bf88831 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.93.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.94.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.93_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.94_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.93
+Meevax Lisp System, version 0.4.94
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index e9bcc870b..54c398496 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.93
+0.4.94
diff --git a/include/meevax/memory/collector.hpp b/include/meevax/memory/collector.hpp
index 3fa78f507..bc4dc489a 100644
--- a/include/meevax/memory/collector.hpp
+++ b/include/meevax/memory/collector.hpp
@@ -170,7 +170,10 @@ inline namespace memory
           collect();
         }
 
-        newest_tracer = tracer_source.new_(data, sizeof(T), deallocator<T>::deallocate);
+        newest_tracer = tracer_source.new_(data, sizeof(T), [](auto * data)
+        {
+          delete static_cast<T *>(data);
+        });
 
         assert(tracers.find(newest_tracer) == std::end(tracers));
 
diff --git a/include/meevax/memory/deallocator.hpp b/include/meevax/memory/deallocator.hpp
deleted file mode 100644
index 26ec2c071..000000000
--- a/include/meevax/memory/deallocator.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-   Copyright 2018-2022 Tatsuya Yamasaki.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-#ifndef INCLUDED_MEEVAX_MEMORY_DEALLOCATOR_HPP
-#define INCLUDED_MEEVAX_MEMORY_DEALLOCATOR_HPP
-
-#include <type_traits>
-
-namespace meevax
-{
-inline namespace memory
-{
-  template <typename T>
-  struct deallocator
-  {
-    using signature = void (*)(void *);
-
-    static void deallocate(void * p)
-    {
-      delete static_cast<T *>(p);
-    }
-  };
-} // namespace memory
-} // namespace meevax
-
-#endif // INCLUDED_MEEVAX_MEMORY_DEALLOCATOR_HPP
diff --git a/include/meevax/memory/tracer.hpp b/include/meevax/memory/tracer.hpp
index ad46d1fdf..fecc1599e 100644
--- a/include/meevax/memory/tracer.hpp
+++ b/include/meevax/memory/tracer.hpp
@@ -21,7 +21,6 @@
 #include <cstdint> // std::uintptr_t
 #include <functional> // std::less
 
-#include <meevax/memory/deallocator.hpp>
 #include <meevax/memory/marker.hpp>
 #include <meevax/utility/debug.hpp>
 
@@ -35,12 +34,12 @@ inline namespace memory
 
     std::size_t const size;
 
-    deallocator<void>::signature const deallocate;
+    using deallocator = void (*)(void *);
+
+    deallocator const deallocate;
 
   public:
-    explicit tracer(void * const,
-                    std::size_t const,
-                    deallocator<void>::signature const = nullptr);
+    explicit tracer(void * const, std::size_t const, deallocator const = nullptr);
 
     ~tracer();
 
diff --git a/src/memory/tracer.cpp b/src/memory/tracer.cpp
index 441581efd..8141ffa97 100644
--- a/src/memory/tracer.cpp
+++ b/src/memory/tracer.cpp
@@ -20,9 +20,7 @@ namespace meevax
 {
 inline namespace memory
 {
-  tracer::tracer(void * const base,
-                 std::size_t const size,
-                 deallocator<void>::signature const deallocate)
+  tracer::tracer(void * const base, std::size_t const size, deallocator const deallocate)
     : base { base }
     , size { size }
     , deallocate { deallocate }

From 69a5027da62fd09dc749cc4fe30ed3d68705d151 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 3 Jul 2022 23:57:47 +0900
Subject: [PATCH 14/36] Move `environment::fork` implementation into .cpp

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +++---
 VERSION                               |  2 +-
 include/meevax/kernel/environment.hpp | 12 ++----------
 src/kernel/environment.cpp            | 12 ++++++++++++
 4 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index f8bf88831..8a63bf076 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.94.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.95.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.94_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.95_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.94
+Meevax Lisp System, version 0.4.95
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 54c398496..1f8d1e231 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.94
+0.4.95
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 7a762d2e2..f0e78df71 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -80,17 +80,9 @@ inline namespace kernel
 
     auto execute(const_reference) -> value_type;
 
-    auto fork() const -> value_type
-    {
-      return make<environment>(*this);
-    }
+    auto fork() const -> value_type;
 
-    auto fork(const_reference scope) const // DIRTY HACK!!!
-    {
-      let const copy = make<environment>(*this);
-      copy.as<environment>().scope() = scope;
-      return copy;
-    }
+    auto fork(const_reference) const -> value_type;
 
     auto global() noexcept -> reference;
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 59f5d67eb..f7b5c8db1 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -119,6 +119,18 @@ inline namespace kernel
     return execute();
   }
 
+  auto environment::fork() const -> value_type
+  {
+    return make<environment>(*this);
+  }
+
+  auto environment::fork(const_reference scope) const -> value_type
+  {
+    let const copy = make<environment>(*this);
+    copy.as<environment>().scope() = scope;
+    return copy;
+  }
+
   auto environment::global() const noexcept -> const_reference
   {
     return second;

From baf739af2b4a3850ea60e676b20c958618e8dd71 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Mon, 4 Jul 2022 00:25:37 +0900
Subject: [PATCH 15/36] Remove `writer::debug_port` and deprecate option
 `--debug`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                              | 8 ++++----
 VERSION                                | 2 +-
 configure/README.md                    | 2 +-
 include/meevax/kernel/configurator.hpp | 2 +-
 include/meevax/kernel/environment.hpp  | 2 +-
 include/meevax/kernel/reader.hpp       | 8 ++++----
 include/meevax/kernel/writer.hpp       | 5 -----
 src/kernel/environment.cpp             | 2 +-
 8 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 8a63bf076..68c360c76 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.95.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.96.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.95_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.96_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,13 +120,13 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.95
+Meevax Lisp System, version 0.4.96
 
 Usage: meevax [OPTION...] [FILE...]
 
 Options:
   -b, --batch            Suppress any system output.
-  -d, --debug            Display detailed informations for developers.
+  -d, --debug            Deprecated.
   -e, --evaluate=STRING  Read and evaluate given STRING at configuration step.
   -h, --help             Display this help text and exit.
   -i, --interactive      Take over control of root environment.
diff --git a/VERSION b/VERSION
index 1f8d1e231..daf98997d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.95
+0.4.96
diff --git a/configure/README.md b/configure/README.md
index ff51d4c63..2819eb48d 100644
--- a/configure/README.md
+++ b/configure/README.md
@@ -126,7 +126,7 @@ Usage: meevax [OPTION...] [FILE...]
 
 Options:
   -b, --batch            Suppress any system output.
-  -d, --debug            Display detailed informations for developers.
+  -d, --debug            Deprecated.
   -e, --evaluate=STRING  Read and evaluate given STRING at configuration step.
   -h, --help             Display this help text and exit.
   -i, --interactive      Take over control of root environment.
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index d9b2496c2..3be92e8f5 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -66,7 +66,7 @@ inline namespace kernel
       print();
       print("Options:");
       print("  -b, --batch            Suppress any system output.");
-      print("  -d, --debug            Display detailed informations for developers.");
+      print("  -d, --debug            Deprecated.");
       print("  -e, --evaluate=STRING  Read and evaluate given STRING at configuration step.");
       print("  -h, --help             Display this help text and exit.");
       print("  -i, --interactive      Take over control of root environment.");
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index f0e78df71..489d13d4d 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -45,7 +45,7 @@ inline namespace kernel
     using reader::read;
 
     using writer::print;
-    using writer::debug_port;
+    using writer::verbose_port;
     using writer::write;
 
     explicit environment(environment &&) = default;
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index 8768ecf1d..ca794474a 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -241,9 +241,9 @@ inline namespace kernel
     explicit reader()
     {}
 
-    IMPORT(Environment, evaluate,   NIL);
-    IMPORT(Environment, debug_port, NIL);
-    IMPORT(Environment, write,      NIL);
+    IMPORT(Environment, evaluate,     NIL);
+    IMPORT(Environment, verbose_port, NIL);
+    IMPORT(Environment, write,        NIL);
 
     using char_type = typename std::istream::char_type;
 
@@ -443,7 +443,7 @@ inline namespace kernel
     {
       let const result = read(standard_input);
 
-      write(debug_port(), pretty::header(__func__), result, "\n");
+      write(verbose_port(), pretty::header(__func__), result, "\n");
 
       return result;
     }
diff --git a/include/meevax/kernel/writer.hpp b/include/meevax/kernel/writer.hpp
index ed1efa393..178030fb1 100644
--- a/include/meevax/kernel/writer.hpp
+++ b/include/meevax/kernel/writer.hpp
@@ -61,11 +61,6 @@ inline namespace kernel
     {
       return Environment::verbose ? standard_output : null_port();
     }
-
-    static auto debug_port() -> const_reference
-    {
-      return Environment::debug ? standard_error : null_port();
-    }
   };
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index f7b5c8db1..e8ab0db63 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -94,7 +94,7 @@ inline namespace kernel
 
       if (debug)
       {
-        disassemble(debug_port().as<std::ostream>(), c);
+        disassemble(verbose_port().as<std::ostream>(), c);
       }
 
       let const result = execute();

From 9189c449003df22d6f2ce2b208c53296ece68b7d Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Mon, 4 Jul 2022 00:37:56 +0900
Subject: [PATCH 16/36] Remove `writer::verbose_port`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                              |  7 +++----
 VERSION                                |  2 +-
 configure/README.md                    |  1 -
 include/meevax/kernel/configurator.hpp |  7 -------
 include/meevax/kernel/environment.hpp  |  2 --
 include/meevax/kernel/reader.hpp       | 11 +++--------
 include/meevax/kernel/writer.hpp       |  5 -----
 src/kernel/environment.cpp             |  5 -----
 8 files changed, 7 insertions(+), 33 deletions(-)

diff --git a/README.md b/README.md
index 68c360c76..b85d25bd5 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.96.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.97.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.96_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.97_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.96
+Meevax Lisp System, version 0.4.97
 
 Usage: meevax [OPTION...] [FILE...]
 
@@ -133,7 +133,6 @@ Options:
   -l, --load=FILENAME    Same as -e '(load FILENAME)'
   -t, --trace            Display stacks of virtual machine for each steps.
   -v, --version          Display version information and exit.
-      --verbose          Display detailed informations.
   -w, --write=OBJECT     Same as -e '(write OBJECT)'
 ```
 
diff --git a/VERSION b/VERSION
index daf98997d..d271a74e0 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.96
+0.4.97
diff --git a/configure/README.md b/configure/README.md
index 2819eb48d..1eb7467cf 100644
--- a/configure/README.md
+++ b/configure/README.md
@@ -133,7 +133,6 @@ Options:
   -l, --load=FILENAME    Same as -e '(load FILENAME)'
   -t, --trace            Display stacks of virtual machine for each steps.
   -v, --version          Display version information and exit.
-      --verbose          Display detailed informations.
   -w, --write=OBJECT     Same as -e '(write OBJECT)'
 ```
 
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index 3be92e8f5..2f09b393e 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -51,7 +51,6 @@ inline namespace kernel
     static inline auto debug       = false;
     static inline auto interactive = true;
     static inline auto trace       = false;
-    static inline auto verbose     = false;
 
     static auto display_version() -> void
     {
@@ -73,7 +72,6 @@ inline namespace kernel
       print("  -l, --load=FILENAME    Same as -e '(load FILENAME)'");
       print("  -t, --trace            Display stacks of virtual machine for each steps.");
       print("  -v, --version          Display version information and exit.");
-      print("      --verbose          Display detailed informations.");
       print("  -w, --write=OBJECT     Same as -e '(write OBJECT)'");
     }
 
@@ -156,11 +154,6 @@ inline namespace kernel
         return make<bool>(trace = true);
       }),
 
-      std::make_pair("verbose", [](auto&&...)
-      {
-        return make<bool>(verbose = true);
-      }),
-
       std::make_pair("version", [](auto&&...) -> value_type
       {
         display_version();
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 489d13d4d..29ee769b6 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -39,13 +39,11 @@ inline namespace kernel
   public:
     using configurator::debug;
     using configurator::trace;
-    using configurator::verbose;
 
     using reader::intern;
     using reader::read;
 
     using writer::print;
-    using writer::verbose_port;
     using writer::write;
 
     explicit environment(environment &&) = default;
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index ca794474a..546da8359 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -241,9 +241,8 @@ inline namespace kernel
     explicit reader()
     {}
 
-    IMPORT(Environment, evaluate,     NIL);
-    IMPORT(Environment, verbose_port, NIL);
-    IMPORT(Environment, write,        NIL);
+    IMPORT(Environment, evaluate, NIL);
+    IMPORT(Environment, write,    NIL);
 
     using char_type = typename std::istream::char_type;
 
@@ -441,11 +440,7 @@ inline namespace kernel
 
     inline auto read() -> value_type
     {
-      let const result = read(standard_input);
-
-      write(verbose_port(), pretty::header(__func__), result, "\n");
-
-      return result;
+      return read(standard_input);
     }
 
     inline auto read(external_representation const& s) -> value_type
diff --git a/include/meevax/kernel/writer.hpp b/include/meevax/kernel/writer.hpp
index 178030fb1..28be8f3db 100644
--- a/include/meevax/kernel/writer.hpp
+++ b/include/meevax/kernel/writer.hpp
@@ -56,11 +56,6 @@ inline namespace kernel
       let static port = make<output_file_port>("/dev/null");
       return port;
     }
-
-    static auto verbose_port() -> const_reference
-    {
-      return Environment::verbose ? standard_output : null_port();
-    }
   };
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index e8ab0db63..9d78a986b 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -92,11 +92,6 @@ inline namespace kernel
 
       c = optimize(c);
 
-      if (debug)
-      {
-        disassemble(verbose_port().as<std::ostream>(), c);
-      }
-
       let const result = execute();
 
       assert(s.is<null>());

From 1fe881ae6c7cb26038648e919b2e1bafc149944c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Mon, 4 Jul 2022 00:41:56 +0900
Subject: [PATCH 17/36] Remove `writer::null_port`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                        | 6 +++---
 VERSION                          | 2 +-
 include/meevax/kernel/writer.hpp | 7 -------
 3 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index b85d25bd5..a6aa42986 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.97.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.98.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.97_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.98_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.97
+Meevax Lisp System, version 0.4.98
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index d271a74e0..6d28dc8c8 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.97
+0.4.98
diff --git a/include/meevax/kernel/writer.hpp b/include/meevax/kernel/writer.hpp
index 28be8f3db..d0eb84797 100644
--- a/include/meevax/kernel/writer.hpp
+++ b/include/meevax/kernel/writer.hpp
@@ -49,13 +49,6 @@ inline namespace kernel
     {
       return write(standard_output, std::forward<decltype(xs)>(xs)..., '\n');
     }
-
-  public:
-    static auto null_port() -> const_reference
-    {
-      let static port = make<output_file_port>("/dev/null");
-      return port;
-    }
   };
 } // namespace kernel
 } // namespace meevax

From 8eb558d77026782472b5272528bddbfe5ceb144c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Mon, 4 Jul 2022 00:59:24 +0900
Subject: [PATCH 18/36] Remove class `writer`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                              |  6 ++--
 VERSION                                |  2 +-
 include/meevax/kernel/configurator.hpp |  3 +-
 include/meevax/kernel/environment.hpp  |  6 ----
 include/meevax/kernel/reader.hpp       |  1 -
 include/meevax/kernel/writer.hpp       | 42 ++++++++++----------------
 src/kernel/environment.cpp             | 10 +++---
 src/kernel/library.cpp                 |  2 +-
 src/main.cpp                           |  6 ++--
 9 files changed, 29 insertions(+), 49 deletions(-)

diff --git a/README.md b/README.md
index a6aa42986..d79b35306 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.98.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.99.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.98_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.99_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.98
+Meevax Lisp System, version 0.4.99
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 6d28dc8c8..76de3545e 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.98
+0.4.99
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index 2f09b393e..697d82ca3 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -24,6 +24,7 @@
 #include <meevax/kernel/interaction_environment.hpp>
 #include <meevax/kernel/procedure.hpp>
 #include <meevax/kernel/version.hpp>
+#include <meevax/kernel/writer.hpp>
 
 namespace meevax
 {
@@ -41,8 +42,6 @@ inline namespace kernel
     IMPORT(environment, load, NIL);
     IMPORT(environment, read, NIL);
 
-    USING_STATIC(environment, print);
-
     template <typename Key>
     using dispatcher = std::unordered_map<Key, procedure::function_type>;
 
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 29ee769b6..4d86cbe24 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -32,7 +32,6 @@ inline namespace kernel
                     , public machine<environment>
                     , public optimizer
                     , public reader<environment>
-                    , public writer<environment>
   {
     using pair::pair;
 
@@ -43,9 +42,6 @@ inline namespace kernel
     using reader::intern;
     using reader::read;
 
-    using writer::print;
-    using writer::write;
-
     explicit environment(environment &&) = default;
 
     explicit environment(environment const&) = default;
@@ -112,8 +108,6 @@ inline namespace kernel
   extern template class machine<environment>;
 
   extern template class reader<environment>;
-
-  extern template class writer<environment>;
 } // namespace kernel
 } // namespace meevax
 
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index 546da8359..e3dcd44a4 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -242,7 +242,6 @@ inline namespace kernel
     {}
 
     IMPORT(Environment, evaluate, NIL);
-    IMPORT(Environment, write,    NIL);
 
     using char_type = typename std::istream::char_type;
 
diff --git a/include/meevax/kernel/writer.hpp b/include/meevax/kernel/writer.hpp
index d0eb84797..4ce5d79ab 100644
--- a/include/meevax/kernel/writer.hpp
+++ b/include/meevax/kernel/writer.hpp
@@ -23,33 +23,23 @@ namespace meevax
 {
 inline namespace kernel
 {
-  template <typename Environment>
-  class writer
+  template <typename... Ts>
+  auto write(std::ostream & os, Ts&&... xs) -> std::ostream &
   {
-    friend Environment;
-
-    explicit writer()
-    {}
-
-  public:
-    template <typename... Ts>
-    static auto write(std::ostream & os, Ts&&... xs) -> std::ostream &
-    {
-      return (os << ... << xs);
-    }
-
-    template <typename... Ts>
-    static auto write(const_reference x, Ts&&... xs) -> decltype(auto)
-    {
-      return write(x.as<std::ostream>(), std::forward<decltype(xs)>(xs)...);
-    }
-
-    template <typename... Ts>
-    static auto print(Ts&&... xs) -> decltype(auto)
-    {
-      return write(standard_output, std::forward<decltype(xs)>(xs)..., '\n');
-    }
-  };
+    return (os << ... << xs);
+  }
+
+  template <typename... Ts>
+  auto write(const_reference x, Ts&&... xs) -> decltype(auto)
+  {
+    return write(x.as<std::ostream>(), std::forward<decltype(xs)>(xs)...);
+  }
+
+  template <typename... Ts>
+  auto print(Ts&&... xs) -> decltype(auto)
+  {
+    return write(standard_output, std::forward<decltype(xs)>(xs)..., '\n');
+  }
 } // namespace kernel
 } // namespace meevax
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 9d78a986b..4a20f0c56 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -261,15 +261,15 @@ inline namespace kernel
 
   auto operator >>(std::istream & is, environment & datum) -> std::istream &
   {
-    datum.print("environment::operator >>(std::istream &, environment &)");
-    datum.print("read new expression => ", datum.read(is));
+    print("environment::operator >>(std::istream &, environment &)");
+    print("read new expression => ", datum.read(is));
 
     return is;
   }
 
-  auto operator <<(std::ostream & os, environment & datum) -> std::ostream &
+  auto operator <<(std::ostream & os, environment &) -> std::ostream &
   {
-    return datum.write(os, "environment::operator <<(std::ostream &, environment &)\n");
+    return write(os, "environment::operator <<(std::ostream &, environment &)\n");
   }
 
   auto operator <<(std::ostream & os, environment const& datum) -> std::ostream &
@@ -282,7 +282,5 @@ inline namespace kernel
   template class machine<environment>;
 
   template class reader<environment>;
-
-  template class writer<environment>;
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index d9f3a2089..4e24117e3 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1016,7 +1016,7 @@ inline namespace kernel
   {
     define<procedure>("%write-simple", [](let const& xs)
     {
-      write(cadr(xs), car(xs));
+      meevax::kernel::write(cadr(xs), car(xs));
       return unspecified;
     });
 
diff --git a/src/main.cpp b/src/main.cpp
index 3cdd734dd..3e9ff250b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -38,9 +38,9 @@ auto main(int const argc, char const* const* const argv) -> int
 
     while (main.interactive and main.char_ready())
     {
-      main.print(u8"\u250c", repeat(u8"\u2500", 79));
-      main.write(standard_output, u8"\u2502\u03bb> ");
-      main.print(main.evaluate(main.read()));
+      print(u8"\u250c", repeat(u8"\u2500", 79));
+      meevax::kernel::write(standard_output, u8"\u2502\u03bb> ");
+      print(main.evaluate(main.read()));
     }
 
     return underlying_cast(exit_status::success);

From b1405cba7fcff7ae63f4fec63711a107c5ff2e2c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Mon, 4 Jul 2022 01:29:25 +0900
Subject: [PATCH 19/36] Remove header `iostream/write.hpp`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                                     |  6 ++--
 VERSION                                       |  2 +-
 include/meevax/iostream/escape_sequence.hpp   | 12 ++++---
 include/meevax/iostream/write.hpp             | 35 -------------------
 include/meevax/kernel/heterogeneous.hpp       |  1 -
 .../utility/unwrap_reference_wrapper.hpp      |  2 +-
 src/kernel/library.cpp                        |  2 +-
 src/main.cpp                                  |  2 +-
 8 files changed, 15 insertions(+), 47 deletions(-)
 delete mode 100644 include/meevax/iostream/write.hpp

diff --git a/README.md b/README.md
index d79b35306..65d572a24 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.99.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.100.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.99_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.100_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.99
+Meevax Lisp System, version 0.4.100
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 76de3545e..d69e3c60f 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.99
+0.4.100
diff --git a/include/meevax/iostream/escape_sequence.hpp b/include/meevax/iostream/escape_sequence.hpp
index 549e9570e..a5c7f9654 100644
--- a/include/meevax/iostream/escape_sequence.hpp
+++ b/include/meevax/iostream/escape_sequence.hpp
@@ -19,9 +19,8 @@
 
 #include <tuple>
 
-#include <meevax/functional/curry.hpp>
 #include <meevax/iostream/is_console.hpp>
-#include <meevax/iostream/write.hpp>
+#include <meevax/utility/unwrap_reference_wrapper.hpp>
 
 namespace meevax
 {
@@ -48,15 +47,20 @@ inline namespace iostream
 
     friend auto operator <<(std::ostream & os, escape_sequence const& sequence) -> std::ostream &
     {
+      auto write = [&](auto&&... xs)
+      {
+        (os << ... << unwrap_reference_wrapper(xs));
+      };
+
       if (is_console(os))
       {
         os << "\x1b[" << sequence.command;
-        std::apply(curry(write)(os), sequence.references);
+        std::apply(write, sequence.references);
         return os << "\x1b[0m";
       }
       else
       {
-        std::apply(curry(write)(os), sequence.references);
+        std::apply(write, sequence.references);
         return os;
       }
     }
diff --git a/include/meevax/iostream/write.hpp b/include/meevax/iostream/write.hpp
deleted file mode 100644
index 64ba9055b..000000000
--- a/include/meevax/iostream/write.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-   Copyright 2018-2022 Tatsuya Yamasaki.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-#ifndef INCLUDED_MEEVAX_IOSTREAM_WRITE_HPP
-#define INCLUDED_MEEVAX_IOSTREAM_WRITE_HPP
-
-#include <iostream>
-
-#include <meevax/utility/unwrap_reference_wrapper.hpp>
-
-namespace meevax
-{
-inline namespace iostream
-{
-  auto write = [](std::ostream & os, auto&&... xs) -> std::ostream &
-  {
-    return (os << ... << unwrap_reference_wrapper(xs));
-  };
-} // namespace iostream
-} // namespace meevax
-
-#endif // INCLUDED_MEEVAX_IOSTREAM_WRITE_HPP
diff --git a/include/meevax/kernel/heterogeneous.hpp b/include/meevax/kernel/heterogeneous.hpp
index c609f3e70..f370e7f41 100644
--- a/include/meevax/kernel/heterogeneous.hpp
+++ b/include/meevax/kernel/heterogeneous.hpp
@@ -19,7 +19,6 @@
 
 #include <meevax/functional/compose.hpp>
 #include <meevax/iostream/escape_sequence.hpp>
-#include <meevax/iostream/write.hpp>
 #include <meevax/kernel/overview.hpp>
 #include <meevax/kernel/profiler.hpp>
 #include <meevax/type_traits/is_equality_comparable.hpp>
diff --git a/include/meevax/utility/unwrap_reference_wrapper.hpp b/include/meevax/utility/unwrap_reference_wrapper.hpp
index 0c5355d4a..59ba951a0 100644
--- a/include/meevax/utility/unwrap_reference_wrapper.hpp
+++ b/include/meevax/utility/unwrap_reference_wrapper.hpp
@@ -28,7 +28,7 @@ inline namespace type_traits
 {
   auto unwrap_reference_wrapper = [](auto&& value) -> decltype(auto)
   {
-    if constexpr (is_reference_wrapper<typename std::decay<decltype(value)>::type>::value)
+    if constexpr (is_reference_wrapper<std::decay_t<decltype(value)>>::value)
     {
       return value.get();
     }
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 4e24117e3..921e28ba6 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1016,7 +1016,7 @@ inline namespace kernel
   {
     define<procedure>("%write-simple", [](let const& xs)
     {
-      meevax::kernel::write(cadr(xs), car(xs));
+      kernel::write(cadr(xs), car(xs));
       return unspecified;
     });
 
diff --git a/src/main.cpp b/src/main.cpp
index 3e9ff250b..1588f98a1 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -39,7 +39,7 @@ auto main(int const argc, char const* const* const argv) -> int
     while (main.interactive and main.char_ready())
     {
       print(u8"\u250c", repeat(u8"\u2500", 79));
-      meevax::kernel::write(standard_output, u8"\u2502\u03bb> ");
+      write(standard_output, u8"\u2502\u03bb> ");
       print(main.evaluate(main.read()));
     }
 

From f36ccff7fd76ed35c8bac38851240f9aa8042ab6 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Tue, 5 Jul 2022 00:26:10 +0900
Subject: [PATCH 20/36] Update `environment::define` to use
 `environment::operator []`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +++---
 VERSION                               |  2 +-
 include/meevax/kernel/environment.hpp | 10 ++++++++--
 src/kernel/environment.cpp            | 18 ++----------------
 4 files changed, 14 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 65d572a24..8006f49cc 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.100.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.101.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.100_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.101_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.100
+Meevax Lisp System, version 0.4.101
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index d69e3c60f..72400f8b0 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.100
+0.4.101
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 4d86cbe24..cf9b919ef 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -52,9 +52,15 @@ inline namespace kernel
       (import(xs), ...);
     }
 
-    auto operator [](const_reference) -> const_reference;
+    auto operator [](const_reference variable) -> decltype(auto)
+    {
+      return identify(variable, scope()).as<identity>().load(e);
+    }
 
-    auto operator [](symbol::value_type const&) -> const_reference;
+    auto operator [](symbol::value_type const& variable) -> decltype(auto)
+    {
+      return (*this)[intern(variable)];
+    }
 
     auto apply(const_reference, const_reference) -> value_type;
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 4a20f0c56..ed35b803b 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -21,16 +21,6 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto environment::operator [](const_reference name) -> const_reference
-  {
-    return identify(name, scope()).as<absolute>().load();
-  }
-
-  auto environment::operator [](external_representation const& name) -> const_reference
-  {
-    return (*this)[intern(name)];
-  }
-
   auto environment::apply(const_reference f, const_reference xs) -> value_type
   {
     assert(f.is<closure>() or f.is<procedure>() or f.is<continuation>());
@@ -53,9 +43,7 @@ inline namespace kernel
 
   auto environment::define(const_reference name, const_reference value) -> void
   {
-    assert(name.is_also<identifier>());
-
-    global() = make<absolute>(name, value) | global();
+    (*this)[name] = value;
   }
 
   auto environment::define(external_representation const& name, const_reference value) -> void
@@ -253,9 +241,7 @@ inline namespace kernel
     *
     * ----------------------------------------------------------------------- */
     {
-      define(variable);
-
-      return car(global());
+      return car(global() = make<absolute>(variable, undefined) | global());
     }
   }
 

From 6e16087f3081422c80cd3a42ad600200e0fec528 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Tue, 5 Jul 2022 01:15:17 +0900
Subject: [PATCH 21/36] Move `environment::apply` into `machine::transformer`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +++---
 VERSION                               |  2 +-
 include/meevax/kernel/environment.hpp |  2 --
 include/meevax/kernel/machine.hpp     | 14 +++++++++++++-
 src/kernel/environment.cpp            | 20 --------------------
 5 files changed, 17 insertions(+), 27 deletions(-)

diff --git a/README.md b/README.md
index 8006f49cc..d7ad8804c 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.101.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.102.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.101_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.102_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.101
+Meevax Lisp System, version 0.4.102
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 72400f8b0..43118e11d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.101
+0.4.102
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index cf9b919ef..097b22382 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -62,8 +62,6 @@ inline namespace kernel
       return (*this)[intern(variable)];
     }
 
-    auto apply(const_reference, const_reference) -> value_type;
-
     auto define(const_reference, const_reference = undefined) -> void;
 
     auto define(symbol::value_type const&, const_reference = undefined) -> void;
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index b61098a4e..a6442cf26 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -60,6 +60,18 @@ inline namespace kernel
         assert(expression.is<closure>());
       }
 
+      auto apply(const_reference f, const_reference xs)
+      {
+        Environment expander;
+
+        expander.s = list(f, xs);
+        expander.e = unit;
+        expander.c = list(make(mnemonic::call), make(mnemonic::stop));
+        expander.d = unit;
+
+        return expander.execute();
+      }
+
       auto expand(const_reference form, const_reference use_env) /* ------------
       *
       *  Scheme programs can define and use new derived expression types,
@@ -91,7 +103,7 @@ inline namespace kernel
       *
       * --------------------------------------------------------------------- */
       {
-        return mac_env.template as<environment>().apply(expression, list(form, use_env, mac_env));
+        return apply(expression, list(form, use_env, mac_env));
       }
 
       friend auto operator <<(std::ostream & os, transformer const& datum) -> std::ostream &
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index ed35b803b..c00f8db48 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -21,26 +21,6 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto environment::apply(const_reference f, const_reference xs) -> value_type
-  {
-    assert(f.is<closure>() or f.is<procedure>() or f.is<continuation>());
-
-    auto dump = std::make_tuple(std::exchange(s, list(f, xs)),
-                                std::exchange(e, unit),
-                                std::exchange(c, list(make(mnemonic::call),
-                                                      make(mnemonic::stop))),
-                                std::exchange(d, unit));
-
-    let const result = execute();
-
-    s = std::get<0>(dump);
-    e = std::get<1>(dump);
-    c = std::get<2>(dump);
-    d = std::get<3>(dump);
-
-    return result;
-  }
-
   auto environment::define(const_reference name, const_reference value) -> void
   {
     (*this)[name] = value;

From 3a0ebfb6a36aa7e3d0c52befe88c7fd44e493ced Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Tue, 5 Jul 2022 01:58:39 +0900
Subject: [PATCH 22/36] Update library to store export-specs as list instead of
 vector

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |  6 +++---
 VERSION                           |  2 +-
 include/meevax/kernel/library.hpp |  2 +-
 include/meevax/kernel/machine.hpp | 32 +++++--------------------------
 src/kernel/library.cpp            |  2 +-
 5 files changed, 11 insertions(+), 33 deletions(-)

diff --git a/README.md b/README.md
index d7ad8804c..504462745 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.102.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.103.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.102_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.103_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.102
+Meevax Lisp System, version 0.4.103
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 43118e11d..2bbd47f40 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.102
+0.4.103
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 91d3c8d3b..f3b364538 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -27,7 +27,7 @@ inline namespace kernel
 {
   struct library : public environment
   {
-    std::vector<value_type> export_specs;
+    let export_specs;
 
     template <typename F, REQUIRES(std::is_invocable<F, library &>)>
     explicit library(F&& declare)
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index a6442cf26..1ca3d6a97 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -174,33 +174,11 @@ inline namespace kernel
     };
 
   public:
-    /* ---- R7RS 4. Expressions ------------------------------------------------
-     *
-     *  <expression> = <identifier>
-     *               | <literal>
-     *               | <procedure call>
-     *               | <lambda expression>
-     *               | <conditional>
-     *               | <assignment>
-     *               | <derived expression>
-     *
-     *  Expression types are categorized as primitive or derived. Primitive
-     *  expression types include variables and procedure calls. Derived
-     *  expression types are not semantically primitive, but can instead be
-     *  defined as macros. Suitable syntax definitions of some of the derived
-     *  expressions are given in section 7.3.
-     *
-     *  The procedures force, promise?, make-promise, and make-parameter are
-     *  also described in this chapter because they are intimately associated
-     *  with the delay, delay-force, and parameterize expression types.
-     *
-     * ---------------------------------------------------------------------- */
-    static auto compile(
-      context         current_context,
-      environment &   current_environment,
-      const_reference current_expression,
-      const_reference current_scope = unit,
-      const_reference current_continuation = list(make(mnemonic::stop))) -> value_type
+    static auto compile(context         current_context,
+                        environment &   current_environment,
+                        const_reference current_expression,
+                        const_reference current_scope = unit,
+                        const_reference current_continuation = list(make(mnemonic::stop)))
     {
       if (current_expression.is<null>()) /* ------------------------------------
       *
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 921e28ba6..96aac7380 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1274,7 +1274,7 @@ inline namespace kernel
 
   auto library::export_(const_reference export_spec) -> void
   {
-    export_specs.push_back(export_spec);
+    export_specs = cons(export_spec, export_specs);
   }
 
   auto library::export_(external_representation const& export_spec) -> void

From 7ba6ece6f9e95098514225b782de456ffb91b167 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Tue, 5 Jul 2022 18:51:55 +0900
Subject: [PATCH 23/36] Add new data member `library::declarations`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |  6 +++---
 VERSION                           |  2 +-
 include/meevax/kernel/library.hpp |  6 +++++-
 include/meevax/kernel/machine.hpp |  2 +-
 src/kernel/library.cpp            | 33 ++++++++++++++++++-------------
 5 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 504462745..e42fba3ca 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.103.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.104.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.103_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.104_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.103
+Meevax Lisp System, version 0.4.104
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 2bbd47f40..0617a7604 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.103
+0.4.104
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index f3b364538..2a4ca4557 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -27,7 +27,9 @@ inline namespace kernel
 {
   struct library : public environment
   {
-    let export_specs;
+    let export_specs = unit;
+
+    let const declarations = unit;
 
     template <typename F, REQUIRES(std::is_invocable<F, library &>)>
     explicit library(F&& declare)
@@ -39,6 +41,8 @@ inline namespace kernel
 
     static auto boot() -> void;
 
+    auto build() -> void;
+
     auto evaluate(const_reference) -> void;
 
     auto export_(const_reference) -> void;
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 1ca3d6a97..857b34cb5 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -178,7 +178,7 @@ inline namespace kernel
                         environment &   current_environment,
                         const_reference current_expression,
                         const_reference current_scope = unit,
-                        const_reference current_continuation = list(make(mnemonic::stop)))
+                        const_reference current_continuation = list(make(mnemonic::stop))) -> value_type
     {
       if (current_expression.is<null>()) /* ------------------------------------
       *
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 96aac7380..29d880144 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1145,11 +1145,9 @@ inline namespace kernel
   }
 
   library::library(const_reference declarations)
+    : declarations { declarations }
   {
-    for (let const& declaration : declarations)
-    {
-      evaluate(declaration);
-    }
+    build();
   }
 
   auto library::boot() -> void
@@ -1248,6 +1246,17 @@ inline namespace kernel
     }
   }
 
+  auto library::build() -> void
+  {
+    if (export_specs.is<null>())
+    {
+      for (let const& declaration : declarations)
+      {
+        evaluate(declaration);
+      }
+    }
+  }
+
   auto library::evaluate(const_reference declaration) -> void
   {
     if (declaration.is<pair>() and car(declaration).is<symbol>()
@@ -1284,36 +1293,32 @@ inline namespace kernel
 
   auto library::resolve_export_specs() -> value_type
   {
-    let bindings = unit;
-
-    for (let const& export_spec : export_specs)
+    return map([this](let const& export_spec)
     {
       if (export_spec.is<pair>() and car(export_spec).is<symbol>()
                                  and car(export_spec).as<symbol>().value == "rename")
       {
         if (let const& binding = identify(cadr(export_spec), unit); binding.as<identity>().is_free())
         {
-          std::cout << error(make<string>("exported but undefined"), cadr(export_spec)) << std::endl;
+          throw error(make<string>("exported but undefined"), cadr(export_spec));
         }
         else
         {
-          bindings = cons(make<absolute>(caddr(export_spec), binding.as<absolute>().load()), bindings);
+          return make<absolute>(caddr(export_spec), binding.as<absolute>().load());
         }
       }
       else
       {
         if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
         {
-          std::cout << error(make<string>("exported but undefined"), export_spec) << std::endl;
+          throw error(make<string>("exported but undefined"), export_spec);
         }
         else
         {
-          bindings = cons(binding, bindings);
+          return binding;
         }
       }
-    }
-
-    return bindings;
+    }, export_specs);
   }
 
   auto operator <<(std::ostream & os, library const& library) -> std::ostream &

From b497d39a6af03c8af17349b7ba7423a49ffb5802 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Tue, 5 Jul 2022 23:43:29 +0900
Subject: [PATCH 24/36] Update to delay library build until needed

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md              | 6 +++---
 VERSION                | 2 +-
 src/kernel/library.cpp | 6 +++---
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index e42fba3ca..bcc75904b 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.104.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.105.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.104_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.105_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.104
+Meevax Lisp System, version 0.4.105
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 0617a7604..4faa72abd 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.104
+0.4.105
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 29d880144..1e4b5fd17 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1146,9 +1146,7 @@ inline namespace kernel
 
   library::library(const_reference declarations)
     : declarations { declarations }
-  {
-    build();
-  }
+  {}
 
   auto library::boot() -> void
   {
@@ -1293,6 +1291,8 @@ inline namespace kernel
 
   auto library::resolve_export_specs() -> value_type
   {
+    build();
+
     return map([this](let const& export_spec)
     {
       if (export_spec.is<pair>() and car(export_spec).is<symbol>()

From 250f6aa12763d28d30f7c281bebc858f57909ac5 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Wed, 6 Jul 2022 01:41:09 +0900
Subject: [PATCH 25/36] Lipsticks

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         |  6 +++---
 VERSION                           |  2 +-
 include/meevax/kernel/library.hpp | 12 +++++++-----
 src/kernel/environment.cpp        | 29 ++++++++++++-----------------
 src/kernel/library.cpp            | 22 +++++++++++-----------
 5 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/README.md b/README.md
index bcc75904b..53ab94168 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.105.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.106.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.105_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.106_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.105
+Meevax Lisp System, version 0.4.106
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 4faa72abd..590365341 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.105
+0.4.106
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 2a4ca4557..b0cad04a7 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -27,14 +27,16 @@ inline namespace kernel
 {
   struct library : public environment
   {
+    let const declarations = unit;
+
     let export_specs = unit;
 
-    let const declarations = unit;
+    let identifiers = unit;
 
-    template <typename F, REQUIRES(std::is_invocable<F, library &>)>
-    explicit library(F&& declare)
+    template <typename Build, REQUIRES(std::is_invocable<Build, library &>)>
+    explicit library(Build&& build)
     {
-      declare(*this);
+      build(*this);
     }
 
     explicit library(const_reference);
@@ -49,7 +51,7 @@ inline namespace kernel
 
     auto export_(external_representation const&) -> void;
 
-    auto resolve_export_specs() -> value_type;
+    auto exported_identifiers() -> const_reference;
 
     #define DEFINE_BASIS_LIBRARY(NAME)                                         \
     struct NAME##_library_t                                                    \
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index c00f8db48..72bef5f70 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -104,45 +104,40 @@ inline namespace kernel
     return second;
   }
 
-  auto resolve_import_set(const_reference import_set) -> value_type
+  auto resolve(const_reference import_set) -> value_type
   {
     if (car(import_set).as<symbol>().value == "only")
     {
-      let const exported_bindings = resolve_import_set(cadr(import_set));
+      let const identities = resolve(cadr(import_set));
 
-      let filtered_bindings = unit;
-
-      for (let const& identifier : cddr(import_set))
+      return map([&](let const& identifier)
       {
-        if (let const& binding = assq(identifier, exported_bindings); select(binding))
+        if (let const& identity = assq(identifier, identities); select(identity))
         {
-          filtered_bindings = cons(binding, filtered_bindings);
+          return identity;
         }
         else
         {
-          throw error(make<string>("no such identifier"), identifier);
+          throw error(make<string>("No such identifier"), identity);
         }
-      }
-
-      return filtered_bindings;
+      }, cddr(import_set));
     }
     else if (auto iter = libraries.find(lexical_cast<external_representation>(import_set)); iter != std::end(libraries))
     {
-      return std::get<1>(*iter).resolve_export_specs();
+      return std::get<1>(*iter).exported_identifiers();
     }
     else
     {
-      throw error(make<string>("no such library"), import_set);
+      throw error(make<string>("No such library"), import_set);
     }
   }
 
   auto environment::import_(const_reference import_set) -> void
   {
-    let const bindings = resolve_import_set(import_set);
-
-    for (let const& binding : bindings)
+    for (let const& identity : resolve(import_set))
     {
-      define(binding.as<absolute>().symbol(), binding.as<absolute>().load());
+      assert(identity.is<absolute>());
+      define(identity.as<absolute>().symbol(), identity.as<absolute>().load());
     }
   }
 
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 1e4b5fd17..000138bd2 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1289,11 +1289,11 @@ inline namespace kernel
     export_(read(export_spec));
   }
 
-  auto library::resolve_export_specs() -> value_type
+  auto library::exported_identifiers() -> const_reference
   {
     build();
 
-    return map([this](let const& export_spec)
+    auto resolve = [this](let const& export_spec)
     {
       if (export_spec.is<pair>() and car(export_spec).is<symbol>()
                                  and car(export_spec).as<symbol>().value == "rename")
@@ -1307,18 +1307,18 @@ inline namespace kernel
           return make<absolute>(caddr(export_spec), binding.as<absolute>().load());
         }
       }
+      else if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
+      {
+        throw error(make<string>("exported but undefined"), export_spec);
+      }
       else
       {
-        if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
-        {
-          throw error(make<string>("exported but undefined"), export_spec);
-        }
-        else
-        {
-          return binding;
-        }
+        return binding;
       }
-    }, export_specs);
+    };
+
+    return identifiers.is<null>() ? identifiers = map(resolve, export_specs)
+                                  : identifiers;
   }
 
   auto operator <<(std::ostream & os, library const& library) -> std::ostream &

From 547d24d3f98e2afb4e0f90971ff89f34005f5da2 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Wed, 6 Jul 2022 19:43:30 +0900
Subject: [PATCH 26/36] Rename free function `map` to `map1`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                         | 6 +++---
 VERSION                           | 2 +-
 include/meevax/kernel/library.hpp | 2 +-
 include/meevax/kernel/list.hpp    | 4 ++--
 include/meevax/kernel/machine.hpp | 4 ++--
 src/kernel/environment.cpp        | 4 ++--
 src/kernel/library.cpp            | 4 ++--
 src/kernel/list.cpp               | 2 +-
 8 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 53ab94168..00b0660eb 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.106.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.107.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.106_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.107_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.106
+Meevax Lisp System, version 0.4.107
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 590365341..ce5a7ad67 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.106
+0.4.107
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index b0cad04a7..19ec290fa 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -51,7 +51,7 @@ inline namespace kernel
 
     auto export_(external_representation const&) -> void;
 
-    auto exported_identifiers() -> const_reference;
+    auto exported_identities() -> const_reference;
 
     #define DEFINE_BASIS_LIBRARY(NAME)                                         \
     struct NAME##_library_t                                                    \
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index aa018d5b2..f8156ae9e 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -195,9 +195,9 @@ inline namespace kernel
   auto unzip2(const_reference xs) -> std::tuple<value_type, value_type>;
 
   template <typename Function>
-  auto map(Function&& function, const_reference x) -> value_type
+  auto map1(Function&& function, const_reference x) -> value_type
   {
-    return x.is<null>() ? unit : cons(function(car(x)), map(function, cdr(x)));
+    return x.is<null>() ? unit : cons(function(car(x)), map1(function, cdr(x)));
   }
 
   auto find = [](const_reference x, auto&& predicate) constexpr -> const_reference
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 857b34cb5..7718a9e06 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -821,7 +821,7 @@ inline namespace kernel
                        current_environment,
                        cons(cons(make<syntax>("lambda", lambda),
                                  unzip1(binding_specs),
-                                 append2(map([](const_reference binding_spec)
+                                 append2(map1([](const_reference binding_spec)
                                              {
                                                return cons(make<syntax>("set!", set), binding_spec);
                                              },
@@ -1119,7 +1119,7 @@ inline namespace kernel
 
       return cons(make(mnemonic::let_syntax),
                   make<syntactic_continuation>(body,
-                                               cons(map(make_keyword, bindings),
+                                               cons(map1(make_keyword, bindings),
                                                     current_scope)),
                   current_continuation);
     }
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 72bef5f70..0abe3500a 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -110,7 +110,7 @@ inline namespace kernel
     {
       let const identities = resolve(cadr(import_set));
 
-      return map([&](let const& identifier)
+      return map1([&](let const& identifier)
       {
         if (let const& identity = assq(identifier, identities); select(identity))
         {
@@ -124,7 +124,7 @@ inline namespace kernel
     }
     else if (auto iter = libraries.find(lexical_cast<external_representation>(import_set)); iter != std::end(libraries))
     {
-      return std::get<1>(*iter).exported_identifiers();
+      return std::get<1>(*iter).exported_identities();
     }
     else
     {
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 000138bd2..f383244d5 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1289,7 +1289,7 @@ inline namespace kernel
     export_(read(export_spec));
   }
 
-  auto library::exported_identifiers() -> const_reference
+  auto library::exported_identities() -> const_reference
   {
     build();
 
@@ -1317,7 +1317,7 @@ inline namespace kernel
       }
     };
 
-    return identifiers.is<null>() ? identifiers = map(resolve, export_specs)
+    return identifiers.is<null>() ? identifiers = map1(resolve, export_specs)
                                   : identifiers;
   }
 
diff --git a/src/kernel/list.cpp b/src/kernel/list.cpp
index c1c212de7..a24f7d5d5 100644
--- a/src/kernel/list.cpp
+++ b/src/kernel/list.cpp
@@ -53,7 +53,7 @@ inline namespace kernel
 
   auto unzip1(const_reference xs) -> value_type
   {
-    return map(car, xs);
+    return map1(car, xs);
   }
 
   auto unzip2(const_reference xs) -> std::tuple<value_type, value_type>

From d172cf946121f28cda44dd801eeb365d03649bad Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 7 Jul 2022 03:31:04 +0900
Subject: [PATCH 27/36] Update `import` declaration to accept form `(except
 ...)`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                      |  6 ++---
 VERSION                        |  2 +-
 basis/r5rs.ss                  |  2 +-
 include/meevax/kernel/list.hpp | 26 ++++++++++++++++++--
 src/kernel/environment.cpp     | 43 +++++++++++++++++++++++++++++++++-
 5 files changed, 71 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 00b0660eb..753e6fa94 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.107.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.108.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.107_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.108_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.107
+Meevax Lisp System, version 0.4.108
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index ce5a7ad67..71986d343 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.107
+0.4.108
diff --git a/basis/r5rs.ss b/basis/r5rs.ss
index 74cffe131..d67f43a45 100644
--- a/basis/r5rs.ss
+++ b/basis/r5rs.ss
@@ -41,7 +41,7 @@
           (meevax evaluate)
           (meevax syntax) ; for let-syntax letrec-syntax
           (scheme r4rs)
-          (scheme r5rs continuation)
+          (except (scheme r5rs continuation) exit)
           (srfi 149))
 
   (export quote lambda if set! cond case and or let let* letrec begin do delay
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index f8156ae9e..50274859e 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -200,9 +200,9 @@ inline namespace kernel
     return x.is<null>() ? unit : cons(function(car(x)), map1(function, cdr(x)));
   }
 
-  auto find = [](const_reference x, auto&& predicate) constexpr -> const_reference
+  auto find = [](const_reference xs, auto&& compare) constexpr -> const_reference
   {
-    if (auto const& iter = std::find_if(std::cbegin(x), std::cend(x), std::forward<decltype(predicate)>(predicate)); iter)
+    if (auto&& iter = std::find_if(std::begin(xs), std::end(xs), compare); iter)
     {
       return *iter;
     }
@@ -234,6 +234,28 @@ inline namespace kernel
   {
     return cons(cons(key, datum), alist);
   };
+
+  auto member = [](const_reference x, const_reference xs, auto&& compare)
+  {
+    if (auto&& iter = std::find_if(std::begin(xs), std::end(xs), [&](auto&& each) { return compare(x, each); }); iter)
+    {
+      return iter.get();
+    }
+    else
+    {
+      return f;
+    }
+  };
+
+  auto memv = [](auto&&... xs) -> decltype(auto)
+  {
+    return member(std::forward<decltype(xs)>(xs)..., eqv);
+  };
+
+  auto memq = [](auto&&... xs) -> decltype(auto)
+  {
+    return member(std::forward<decltype(xs)>(xs)..., eq);
+  };
 } // namespace kernel
 } // namespace meevax
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 0abe3500a..fffe46ae3 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -106,7 +106,11 @@ inline namespace kernel
 
   auto resolve(const_reference import_set) -> value_type
   {
-    if (car(import_set).as<symbol>().value == "only")
+    if (car(import_set).as<symbol>().value == "only") /* -----------------------
+    *
+    *  (only <import set> <identifier> ...)
+    *
+    * ----------------------------------------------------------------------- */
     {
       let const identities = resolve(cadr(import_set));
 
@@ -122,6 +126,43 @@ inline namespace kernel
         }
       }, cddr(import_set));
     }
+    else if (car(import_set).as<symbol>().value == "except") /* ----------------
+    *
+    *  (except <import set> <identifier> ...)
+    *
+    * ----------------------------------------------------------------------- */
+    {
+      let const ids = resolve(cadr(import_set));
+
+      let result = unit;
+
+      for (let const& id : ids)
+      {
+        if (let const& x = memq(id, cddr(import_set)); not select(x))
+        {
+          result = cons(id, result);
+        }
+      }
+
+      return result;
+    }
+    else if (car(import_set).as<symbol>().value == "prefix") /* ----------------
+    *
+    *  (prefix <import set> <identifier> ...)
+    *
+    * ----------------------------------------------------------------------- */
+    {
+      throw error(make<string>("Unsupported"), car(import_set));
+    }
+    else if (car(import_set).as<symbol>().value == "rename") /* ----------------
+    *
+    *  (rename <import set>
+    *          (<identifier 1> <identifier 2>) ...)
+    *
+    * ----------------------------------------------------------------------- */
+    {
+      throw error(make<string>("Unsupported"), car(import_set));
+    }
     else if (auto iter = libraries.find(lexical_cast<external_representation>(import_set)); iter != std::end(libraries))
     {
       return std::get<1>(*iter).exported_identities();

From 85ab421cb81f3f7f07f4355dbbbbcd39b6f98e8c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Thu, 7 Jul 2022 04:09:44 +0900
Subject: [PATCH 28/36] Remove template `equivalence_comparator`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +++---
 VERSION                               |  2 +-
 include/meevax/kernel/equivalence.hpp | 28 +++---------------------
 include/meevax/kernel/list.hpp        | 31 ++++++++++++---------------
 src/kernel/environment.cpp            |  4 +---
 5 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/README.md b/README.md
index 753e6fa94..c29f2f709 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.108.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.109.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.108_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.109_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.108
+Meevax Lisp System, version 0.4.109
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 71986d343..61ff7e57c 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.108
+0.4.109
diff --git a/include/meevax/kernel/equivalence.hpp b/include/meevax/kernel/equivalence.hpp
index 7bbf8319c..76529d406 100644
--- a/include/meevax/kernel/equivalence.hpp
+++ b/include/meevax/kernel/equivalence.hpp
@@ -23,39 +23,17 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto eq = [](auto const& x, auto const& y) constexpr // address=? or reference=?
+  auto eq = [](auto const& x, auto const& y) constexpr
   {
     return x == y;
   };
 
-  auto eqv = [](auto const& x, auto const& y) // value=?
+  auto eqv = [](auto const& x, auto const& y)
   {
     return eq(x, y) or x.compare(y);
   };
 
-  auto equal(const_reference, const_reference) -> bool; // structure=?
-
-  template <std::size_t Coarseness = 0>
-  struct equivalence_comparator;
-
-  #define SPECIALIZE_EQUIVALENCE_COMPARATOR(COARSENESS, COMPARE)               \
-  template <>                                                                  \
-  struct equivalence_comparator<COARSENESS>                                    \
-  {                                                                            \
-    template <typename... Ts>                                                  \
-    constexpr auto operator ()(Ts&&... xs) const -> bool                       \
-    {                                                                          \
-      return COMPARE(std::forward<decltype(xs)>(xs)...);                       \
-    }                                                                          \
-  }
-
-  SPECIALIZE_EQUIVALENCE_COMPARATOR(0, eq);
-  SPECIALIZE_EQUIVALENCE_COMPARATOR(1, eqv);
-  SPECIALIZE_EQUIVALENCE_COMPARATOR(2, equal);
-
-  #undef SPECIALIZE_EQUIVALENCE_COMPARATOR
-
-  using default_equivalence_comparator = equivalence_comparator<>;
+  auto equal(const_reference, const_reference) -> bool;
 } // namespace kernel
 } // namespace meevax
 
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 50274859e..6454b32fc 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -33,11 +33,11 @@ inline namespace kernel
   {
     if constexpr (std::is_same_v<std::decay_t<decltype(x)>, iterator>)
     {
-      return std::get<N>(x.get().template as<pair>());
+      return std::get<N>(*x.get());
     }
     else if constexpr (std::is_same_v<std::decay_t<decltype(x)>, value_type>)
     {
-      return x.template is<null>() ? unit : std::get<N>(x.template as<pair>());
+      return x.template is<null>() ? unit : std::get<N>(*x);
     }
     else
     {
@@ -194,10 +194,10 @@ inline namespace kernel
 
   auto unzip2(const_reference xs) -> std::tuple<value_type, value_type>;
 
-  template <typename Function>
-  auto map1(Function&& function, const_reference x) -> value_type
+  template <typename F>
+  auto map1(F&& f, const_reference x) -> value_type
   {
-    return x.is<null>() ? unit : cons(function(car(x)), map1(function, cdr(x)));
+    return x.is<null>() ? unit : cons(f(car(x)), map1(f, cdr(x)));
   }
 
   auto find = [](const_reference xs, auto&& compare) constexpr -> const_reference
@@ -212,25 +212,22 @@ inline namespace kernel
     }
   };
 
-  auto assoc = [](const_reference key, const_reference alist, auto&& compare = equivalence_comparator<2>()) -> const_reference
+  auto assoc = [](const_reference x, const_reference xs, auto&& compare)
   {
-    return find(alist, [&](auto&& each)
-    {
-      return compare(car(each), key);
-    });
+    return find(xs, [&](auto&& each) { return compare(x, car(each)); });
   };
 
-  auto assv = [](auto&&... xs) -> const_reference
+  auto assv = [](auto&&... xs)
   {
-    return assoc(std::forward<decltype(xs)>(xs)..., equivalence_comparator<1>());
+    return assoc(std::forward<decltype(xs)>(xs)..., eqv);
   };
 
-  auto assq = [](auto&&... xs) -> const_reference
+  auto assq = [](auto&&... xs)
   {
-    return assoc(std::forward<decltype(xs)>(xs)..., equivalence_comparator<0>());
+    return assoc(std::forward<decltype(xs)>(xs)..., eq);
   };
 
-  auto alist_cons = [](auto&& key, auto&& datum, auto&& alist) constexpr
+  auto alist_cons = [](auto&& key, auto&& datum, auto&& alist)
   {
     return cons(cons(key, datum), alist);
   };
@@ -247,12 +244,12 @@ inline namespace kernel
     }
   };
 
-  auto memv = [](auto&&... xs) -> decltype(auto)
+  auto memv = [](auto&&... xs)
   {
     return member(std::forward<decltype(xs)>(xs)..., eqv);
   };
 
-  auto memq = [](auto&&... xs) -> decltype(auto)
+  auto memq = [](auto&&... xs)
   {
     return member(std::forward<decltype(xs)>(xs)..., eq);
   };
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index fffe46ae3..fe1f86cc9 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -132,11 +132,9 @@ inline namespace kernel
     *
     * ----------------------------------------------------------------------- */
     {
-      let const ids = resolve(cadr(import_set));
-
       let result = unit;
 
-      for (let const& id : ids)
+      for (let const& id : resolve(cadr(import_set)))
       {
         if (let const& x = memq(id, cddr(import_set)); not select(x))
         {

From 7dfdbf57e6887e2ed118a737e9ec1820f0c20512 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 13:03:56 +0900
Subject: [PATCH 29/36] Update implementation of `only` and `except` in
 `import` declaration to be symmetric

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                           |  6 +--
 VERSION                             |  2 +-
 benchmark/ack.ss                    |  2 +-
 benchmark/tarai.ss                  |  2 +-
 include/meevax/functional/curry.hpp | 15 +++---
 include/meevax/kernel/list.hpp      | 32 +++++++++++++
 src/kernel/environment.cpp          | 74 ++++++++++++++++-------------
 7 files changed, 87 insertions(+), 46 deletions(-)

diff --git a/README.md b/README.md
index c29f2f709..1cbd3a54b 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.109.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.110.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.109_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.110_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.109
+Meevax Lisp System, version 0.4.110
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 61ff7e57c..57480fc7e 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.109
+0.4.110
diff --git a/benchmark/ack.ss b/benchmark/ack.ss
index 6ac974da6..e303120f6 100644
--- a/benchmark/ack.ss
+++ b/benchmark/ack.ss
@@ -1,4 +1,4 @@
-(import (scheme r5rs)
+(import (scheme base)
         (scheme process-context))
 
 (define (ack m n)
diff --git a/benchmark/tarai.ss b/benchmark/tarai.ss
index 8460d3780..ecadb83c5 100644
--- a/benchmark/tarai.ss
+++ b/benchmark/tarai.ss
@@ -1,4 +1,4 @@
-(import (scheme r5rs)
+(import (scheme base)
         (scheme process-context))
 
 (define (tarai x y z)
diff --git a/include/meevax/functional/curry.hpp b/include/meevax/functional/curry.hpp
index 6de1b6f13..35a3400f5 100644
--- a/include/meevax/functional/curry.hpp
+++ b/include/meevax/functional/curry.hpp
@@ -23,15 +23,18 @@ namespace meevax
 {
 inline namespace functional
 {
-  template <typename Function>
-  constexpr auto curry(Function&& function) -> decltype(auto)
+  template <typename F>
+  constexpr auto curry(F&& f) -> decltype(auto)
   {
-    return [&](auto&&... xs)
+    return [f](auto&&... xs)
     {
-      return [&](auto&&... ys) -> decltype(auto)
+      return [f, xs = std::make_tuple(std::forward<decltype(xs)>(xs)...)](auto&&... ys)
       {
-        return function(std::forward<decltype(xs)>(xs)...,
-                        std::forward<decltype(ys)>(ys)...);
+        return std::apply([&](auto&&... xs)
+                          {
+                            return f(std::forward<decltype(xs)>(xs)...,
+                                     std::forward<decltype(ys)>(ys)...);
+                          }, xs);
       };
     };
   }
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 6454b32fc..299582997 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -253,6 +253,38 @@ inline namespace kernel
   {
     return member(std::forward<decltype(xs)>(xs)..., eq);
   };
+
+  auto filter = [](auto&& satisfy, const_reference xs)
+  {
+    auto recur = [&](auto&& recur, let const& xs)
+    {
+      if (xs.is<null>())
+      {
+        return xs;
+      }
+      else
+      {
+        if (let const& head = car(xs),
+                       rest = cdr(xs); satisfy(head))
+        {
+          if (let const& new_tail = recur(recur, rest); eq(rest, new_tail))
+          {
+            return xs;
+          }
+          else
+          {
+            return cons(head, new_tail);
+          }
+        }
+        else
+        {
+          return recur(recur, rest);
+        }
+      }
+    };
+
+    return z(recur)(xs);
+  };
 } // namespace kernel
 } // namespace meevax
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index fe1f86cc9..4d54c4c6d 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -104,70 +104,76 @@ inline namespace kernel
     return second;
   }
 
-  auto resolve(const_reference import_set) -> value_type
+  auto resolve(const_reference declaration) -> value_type
   {
-    if (car(import_set).as<symbol>().value == "only") /* -----------------------
+    if (car(declaration).as<symbol>().value == "only") /* ----------------------
     *
-    *  (only <import set> <identifier> ...)
+    *  <declaration> = (only <import set> <identifier> ...)
     *
     * ----------------------------------------------------------------------- */
     {
-      let const identities = resolve(cadr(import_set));
-
-      return map1([&](let const& identifier)
+      auto only = [](let const& import_set)
       {
-        if (let const& identity = assq(identifier, identities); select(identity))
-        {
-          return identity;
-        }
-        else
+        return [=](let const& identifiers)
         {
-          throw error(make<string>("No such identifier"), identity);
-        }
-      }, cddr(import_set));
+          return filter([&](let const& identity)
+                        {
+                          return select(memq(identity.as<meevax::identity>().symbol(),
+                                             identifiers));
+                        },
+                        resolve(import_set));
+        };
+      };
+
+      return only(cadr(declaration))
+                 (cddr(declaration));
     }
-    else if (car(import_set).as<symbol>().value == "except") /* ----------------
+    else if (car(declaration).as<symbol>().value == "except") /* ---------------
     *
-    *  (except <import set> <identifier> ...)
+    *  <declaration> = (except <import set> <identifier> ...)
     *
     * ----------------------------------------------------------------------- */
     {
-      let result = unit;
-
-      for (let const& id : resolve(cadr(import_set)))
+      auto except = [](let const& import_set)
       {
-        if (let const& x = memq(id, cddr(import_set)); not select(x))
+        return [=](let const& identifiers)
         {
-          result = cons(id, result);
-        }
-      }
-
-      return result;
+          return filter([&](let const& identity)
+                        {
+                          return not select(memq(identity.as<meevax::identity>().symbol(),
+                                                 identifiers));
+                        },
+                        resolve(import_set));
+        };
+      };
+
+      return except(cadr(declaration))
+                   (cddr(declaration));
     }
-    else if (car(import_set).as<symbol>().value == "prefix") /* ----------------
+    else if (car(declaration).as<symbol>().value == "prefix") /* ---------------
     *
-    *  (prefix <import set> <identifier> ...)
+    *  <declaration> = (prefix <import set> <identifier> ...)
     *
     * ----------------------------------------------------------------------- */
     {
-      throw error(make<string>("Unsupported"), car(import_set));
+      throw error(make<string>("Unsupported"), car(declaration));
     }
-    else if (car(import_set).as<symbol>().value == "rename") /* ----------------
+    else if (car(declaration).as<symbol>().value == "rename") /* ---------------
     *
-    *  (rename <import set>
-    *          (<identifier 1> <identifier 2>) ...)
+    *  <declaration> = (rename <import set>
+    *                          (<identifier 1> <identifier 2>) ...)
     *
     * ----------------------------------------------------------------------- */
     {
-      throw error(make<string>("Unsupported"), car(import_set));
+      throw error(make<string>("Unsupported"), car(declaration));
     }
-    else if (auto iter = libraries.find(lexical_cast<external_representation>(import_set)); iter != std::end(libraries))
+    else if (auto iter = libraries.find(lexical_cast<external_representation>(declaration)); iter != std::end(libraries))
     {
       return std::get<1>(*iter).exported_identities();
     }
     else
     {
-      throw error(make<string>("No such library"), import_set);
+      throw error(make<string>("No such library"), declaration);
     }
   }
 

From def03b189bebf689a3e7e896c1f6835ef03fa968 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 13:21:03 +0900
Subject: [PATCH 30/36] Rename `library::exported_identities` to `resolve`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                           |  6 +++---
 VERSION                             |  2 +-
 include/meevax/functional/curry.hpp |  1 +
 include/meevax/kernel/library.hpp   |  2 +-
 include/meevax/kernel/list.hpp      | 10 +++++-----
 src/kernel/environment.cpp          |  2 +-
 src/kernel/library.cpp              |  6 +++---
 7 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 1cbd3a54b..d286a1d76 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.110.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.111.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.110_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.111_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.110
+Meevax Lisp System, version 0.4.111
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 57480fc7e..74d996944 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.110
+0.4.111
diff --git a/include/meevax/functional/curry.hpp b/include/meevax/functional/curry.hpp
index 35a3400f5..089182ed0 100644
--- a/include/meevax/functional/curry.hpp
+++ b/include/meevax/functional/curry.hpp
@@ -17,6 +17,7 @@
 #ifndef INCLUDED_MEEVAX_FUNCTIONAL_CURRY_HPP
 #define INCLUDED_MEEVAX_FUNCTIONAL_CURRY_HPP
 
+#include <tuple>
 #include <utility>
 
 namespace meevax
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 19ec290fa..57f45e8b8 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -51,7 +51,7 @@ inline namespace kernel
 
     auto export_(external_representation const&) -> void;
 
-    auto exported_identities() -> const_reference;
+    auto resolve() -> const_reference;
 
     #define DEFINE_BASIS_LIBRARY(NAME)                                         \
     struct NAME##_library_t                                                    \
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 299582997..5617d37fd 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -256,7 +256,7 @@ inline namespace kernel
 
   auto filter = [](auto&& satisfy, const_reference xs)
   {
-    auto recur = [&](auto&& recur, let const& xs)
+    auto filter = [&](auto&& filter, let const& xs)
     {
       if (xs.is<null>())
       {
@@ -267,23 +267,23 @@ inline namespace kernel
         if (let const& head = car(xs),
                        rest = cdr(xs); satisfy(head))
         {
-          if (let const& new_tail = recur(recur, rest); eq(rest, new_tail))
+          if (let const& filtered = filter(filter, rest); eq(rest, filtered))
           {
             return xs;
           }
           else
           {
-            return cons(head, new_tail);
+            return cons(head, filtered);
           }
         }
         else
         {
-          return recur(recur, rest);
+          return filter(filter, rest);
         }
       }
     };
 
-    return z(recur)(xs);
+    return z(filter)(xs);
   };
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 4d54c4c6d..cb440fd0c 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -169,7 +169,7 @@ inline namespace kernel
     }
     else if (auto iter = libraries.find(lexical_cast<external_representation>(declaration)); iter != std::end(libraries))
     {
-      return std::get<1>(*iter).exported_identities();
+      return std::get<1>(*iter).resolve();
     }
     else
     {
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index f383244d5..c3847297e 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -1289,7 +1289,7 @@ inline namespace kernel
     export_(read(export_spec));
   }
 
-  auto library::exported_identities() -> const_reference
+  auto library::resolve() -> const_reference
   {
     build();
 
@@ -1300,7 +1300,7 @@ inline namespace kernel
       {
         if (let const& binding = identify(cadr(export_spec), unit); binding.as<identity>().is_free())
         {
-          throw error(make<string>("exported but undefined"), cadr(export_spec));
+          throw error(make<string>("Exported but undefined"), cadr(export_spec));
         }
         else
         {
@@ -1309,7 +1309,7 @@ inline namespace kernel
       }
       else if (let const& binding = identify(export_spec, unit); binding.as<identity>().is_free())
       {
-        throw error(make<string>("exported but undefined"), export_spec);
+        throw error(make<string>("Exported but undefined"), export_spec);
       }
       else
       {

From cfa5561dfe070c0a56a12954f9f62ee1db55478f Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 14:18:23 +0900
Subject: [PATCH 31/36] Update `import` declaration to accept form `(prefix
 ...)`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                             |  6 +++---
 VERSION                               |  2 +-
 include/meevax/kernel/environment.hpp |  2 ++
 src/kernel/environment.cpp            | 29 ++++++++++++++++++++-------
 4 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index d286a1d76..9d9fac7e3 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.111.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.112.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.111_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.112_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.111
+Meevax Lisp System, version 0.4.112
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 74d996944..269e7dde5 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.111
+0.4.112
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 097b22382..a60bdd751 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -92,6 +92,8 @@ inline namespace kernel
 
     auto load(external_representation const&) -> value_type;
 
+    auto resolve(const_reference) -> value_type;
+
     auto scope() const noexcept -> const_reference;
 
     auto scope() noexcept -> reference;
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index cb440fd0c..ad9bef26b 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -104,7 +104,7 @@ inline namespace kernel
     return second;
   }
 
-  auto resolve(const_reference declaration) -> value_type
+  auto environment::resolve(const_reference declaration) -> value_type
   {
     if (car(declaration).as<symbol>().value == "only") /* ----------------------
     *
@@ -112,13 +112,13 @@ inline namespace kernel
     *
     * ----------------------------------------------------------------------- */
     {
-      auto only = [](let const& import_set)
+      auto only = [this](let const& import_set)
       {
         return [=](let const& identifiers)
         {
           return filter([&](let const& identity)
                         {
-                          return select(memq(identity.as<meevax::identity>().symbol(),
+                          return select(memq(identity.as<absolute>().symbol(),
                                              identifiers));
                         },
                         resolve(import_set));
@@ -134,13 +134,13 @@ inline namespace kernel
     *
     * ----------------------------------------------------------------------- */
     {
-      auto except = [](let const& import_set)
+      auto except = [this](let const& import_set)
       {
         return [=](let const& identifiers)
         {
           return filter([&](let const& identity)
                         {
-                          return not select(memq(identity.as<meevax::identity>().symbol(),
+                          return not select(memq(identity.as<absolute>().symbol(),
                                                  identifiers));
                         },
                         resolve(import_set));
@@ -152,11 +152,26 @@ inline namespace kernel
     }
     else if (car(declaration).as<symbol>().value == "prefix") /* ---------------
     *
-    *  <declaration> = (prefix <import set> <identifier> ...)
+    *  <declaration> = (prefix <import set> <identifier>)
     *
     * ----------------------------------------------------------------------- */
     {
-      throw error(make<string>("Unsupported"), car(declaration));
+      auto prefix = [this](let const& import_set)
+      {
+        return [=](let const& identifier)
+        {
+          return map1([&](let const& identity)
+                      {
+                        return make<absolute>(intern(identifier.as<symbol>().value +
+                                                     identity.as<absolute>().symbol().as<symbol>().value),
+                                              identity.as<absolute>().load());
+                      },
+                      resolve(import_set));
+        };
+      };
+
+      return prefix(cadr(declaration))
+                   (caddr(declaration));
     }
     else if (car(declaration).as<symbol>().value == "rename") /* ---------------
     *

From 5abffeb54cda1847bde2d5882fbd74ceec1a106c Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 15:27:23 +0900
Subject: [PATCH 32/36] Update `import` declaration to accept form `(rename
 ...)`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                  |  6 +++---
 VERSION                    |  2 +-
 src/kernel/environment.cpp | 31 +++++++++++++++++++++++++++----
 3 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 9d9fac7e3..ea80304a4 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.112.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.113.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.112_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.113_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.112
+Meevax Lisp System, version 0.4.113
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 269e7dde5..f67377877 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.112
+0.4.113
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index ad9bef26b..58676a5c5 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -158,11 +158,11 @@ inline namespace kernel
     {
       auto prefix = [this](let const& import_set)
       {
-        return [=](let const& identifier)
+        return [=](let const& prefixes)
         {
           return map1([&](let const& identity)
                       {
-                        return make<absolute>(intern(identifier.as<symbol>().value +
+                        return make<absolute>(intern(car(prefixes).as<symbol>().value +
                                                      identity.as<absolute>().symbol().as<symbol>().value),
                                               identity.as<absolute>().load());
                       },
@@ -171,7 +171,7 @@ inline namespace kernel
       };
 
       return prefix(cadr(declaration))
-                   (caddr(declaration));
+                   (cadr(declaration));
     }
     else if (car(declaration).as<symbol>().value == "rename") /* ---------------
     *
@@ -180,7 +180,30 @@ inline namespace kernel
     *
     * ----------------------------------------------------------------------- */
     {
-      throw error(make<string>("Unsupported"), car(declaration));
+      auto rename = [this](let const& import_set)
+      {
+        return [=](let const& renamings)
+        {
+          return map1([&](let const& identity)
+                      {
+                        if (let const& renaming = assq(identity.as<absolute>().symbol(),
+                                                       renamings);
+                            select(renaming))
+                        {
+                          assert(cadr(renaming).is<symbol>());
+                          return make<absolute>(cadr(renaming), identity.as<absolute>().load());
+                        }
+                        else
+                        {
+                          return identity;
+                        }
+                      },
+                      resolve(import_set));
+        };
+      };
+
+      return rename(cadr(declaration))
+                   (cddr(declaration));
     }
     else if (auto iter = libraries.find(lexical_cast<external_representation>(declaration)); iter != std::end(libraries))
     {

From 9253017cc40029d66049d186eccd7e1d6711e1bc Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 16:56:15 +0900
Subject: [PATCH 33/36] Update `import` declaration to throw error if detect
 redefinition

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md                  |  6 +++---
 VERSION                    |  2 +-
 basis/r4rs-essential.ss    |  4 ++--
 basis/r4rs.ss              | 10 +++++-----
 basis/r5rs.ss              |  6 +++---
 basis/srfi-149.ss          |  4 ++--
 basis/srfi-45.ss           |  2 +-
 src/kernel/environment.cpp | 11 ++++++++++-
 test/identifier.ss         |  2 +-
 test/letrec-syntax.ss      |  4 ++--
 test/r4rs-appendix.ss      |  2 +-
 test/transformer.ss        |  6 +++---
 12 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index ea80304a4..915974185 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.113.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.114.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.113_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.114_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.113
+Meevax Lisp System, version 0.4.114
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index f67377877..c027bee4e 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.113
+0.4.114
diff --git a/basis/r4rs-essential.ss b/basis/r4rs-essential.ss
index 92ea6560d..f613ad626 100644
--- a/basis/r4rs-essential.ss
+++ b/basis/r4rs-essential.ss
@@ -556,9 +556,9 @@
                result))
            (call-with-output-port (open-output-file path) f))
 
-         (define current-input-port standard-input-port)  ; r7rs incompatible (current-input-port is standard input)
+         (define current-input-port standard-input-port) ; r7rs incompatible (current-input-port is standard input)
 
-         (define current-output-port standard-output-port)  ; r7rs incompatible (current-output-port is standard output)
+         (define current-output-port standard-output-port) ; r7rs incompatible (current-output-port is standard output)
 
          (define (read . port)
            (%read (if (pair? port)
diff --git a/basis/r4rs.ss b/basis/r4rs.ss
index ca9c0d102..617494b67 100644
--- a/basis/r4rs.ss
+++ b/basis/r4rs.ss
@@ -1,10 +1,10 @@
 (define-library (scheme r4rs)
   (import (meevax inexact)
-          (meevax number) ; for exact-integer?
-          (meevax port) ; for read-ready?
-          (meevax string) ; for string-copy
-          (meevax syntax) ; for define-syntax
-          (meevax vector) ; for vector-fill!
+          (only (meevax number) exact-integer? expt exact inexact ratio?)
+          (only (meevax port) read-ready? standard-input-port standard-output-port)
+          (only (meevax string) string-copy)
+          (only (meevax syntax) define-syntax)
+          (only (meevax vector) vector-fill!)
           (scheme r4rs essential)
           (srfi 45)
           (srfi 211 explicit-renaming))
diff --git a/basis/r5rs.ss b/basis/r5rs.ss
index d67f43a45..9adbf9d6e 100644
--- a/basis/r5rs.ss
+++ b/basis/r5rs.ss
@@ -1,6 +1,6 @@
 (define-library (scheme r5rs continuation)
   (import (meevax context)
-          (meevax syntax)
+          (only (meevax syntax) define-syntax)
           (scheme r4rs essential))
 
   (export call-with-current-continuation dynamic-wind exit)
@@ -39,8 +39,8 @@
 (define-library (scheme r5rs)
   (import (meevax environment)
           (meevax evaluate)
-          (meevax syntax) ; for let-syntax letrec-syntax
-          (scheme r4rs)
+          (only (meevax syntax) define-syntax let-syntax letrec-syntax)
+          (except (scheme r4rs) call-with-current-continuation!)
           (except (scheme r5rs continuation) exit)
           (srfi 149))
 
diff --git a/basis/srfi-149.ss b/basis/srfi-149.ss
index b298c3eb5..77ff533f9 100644
--- a/basis/srfi-149.ss
+++ b/basis/srfi-149.ss
@@ -24,8 +24,8 @@
 ; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 (define-library (srfi 149)
-  (import (meevax macro)
-          (meevax syntax) ; for define-syntax
+  (import (only (meevax macro) identifier->symbol)
+          (only (meevax syntax) define-syntax quote-syntax)
           (scheme r4rs)
           (srfi 211 explicit-renaming)
           )
diff --git a/basis/srfi-45.ss b/basis/srfi-45.ss
index 82be43528..a8da43ada 100644
--- a/basis/srfi-45.ss
+++ b/basis/srfi-45.ss
@@ -1,6 +1,6 @@
 (define-library (srfi 45) ; Based on r7rs reference implementation.
   (import (scheme r4rs essential)
-          (meevax syntax) ; for define-syntax
+          (only (meevax syntax) define-syntax)
           (srfi 211 explicit-renaming))
 
   (export delay eager force lazy promise?)
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 58676a5c5..a8b0bab33 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -220,7 +220,16 @@ inline namespace kernel
     for (let const& identity : resolve(import_set))
     {
       assert(identity.is<absolute>());
-      define(identity.as<absolute>().symbol(), identity.as<absolute>().load());
+
+      if (let const& variable = identity.as<absolute>().symbol(); not eq((*this)[variable], undefined) and not interactive)
+      {
+        throw error(make<string>("In a program or library declaration, it is an error to import the same identifier more than once with different bindings"),
+                    list(import_set, variable));
+      }
+      else
+      {
+        define(identity.as<absolute>().symbol(), identity.as<absolute>().load());
+      }
     }
   }
 
diff --git a/test/identifier.ss b/test/identifier.ss
index 3d2ee4749..8ff553bfb 100644
--- a/test/identifier.ss
+++ b/test/identifier.ss
@@ -1,4 +1,4 @@
-(import (meevax macro)
+(import (only (meevax macro) syntactic-closure?)
         (scheme base)
         (scheme process-context)
         (srfi 78)
diff --git a/test/letrec-syntax.ss b/test/letrec-syntax.ss
index 9dd6507af..49ebd3065 100644
--- a/test/letrec-syntax.ss
+++ b/test/letrec-syntax.ss
@@ -1,8 +1,8 @@
 (import (scheme base)
         (scheme process-context)
         (srfi 78)
-        (srfi 211 explicit-renaming)
-        (srfi 211 syntactic-closures))
+        (except (srfi 211 syntactic-closures) identifier?)
+        (srfi 211 explicit-renaming))
 
 (letrec-syntax ((my-and (er-macro-transformer
                           (lambda (form rename compare)
diff --git a/test/r4rs-appendix.ss b/test/r4rs-appendix.ss
index 19f384e84..16c5a7105 100644
--- a/test/r4rs-appendix.ss
+++ b/test/r4rs-appendix.ss
@@ -1,7 +1,7 @@
 (import (scheme base)
         (scheme process-context)
         (srfi 78)
-        (srfi 211 syntactic-closures)
+        (except (srfi 211 syntactic-closures) identifier?)
         (srfi 211 explicit-renaming))
 
 ; (check (symbol? (syntax x)) => #f)
diff --git a/test/transformer.ss b/test/transformer.ss
index 0a68ee9e9..e44a22cfd 100644
--- a/test/transformer.ss
+++ b/test/transformer.ss
@@ -1,10 +1,10 @@
-(import (only (meevax macro) transformer?)
+(import (only (meevax macro) identifier? transformer?)
         (scheme base)
         (scheme cxr)
         (scheme process-context)
         (srfi 78)
-        (srfi 211 syntactic-closures)
-        (srfi 211 explicit-renaming)
+        (except (srfi 211 syntactic-closures) identifier?)
+        (except (srfi 211 explicit-renaming) identifier?)
         )
 
 (define (traditional-macro-transformer f)

From 951a0479fc5e0c4885ff8f2f9356ae5a53f3ad33 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sat, 9 Jul 2022 20:18:40 +0900
Subject: [PATCH 34/36] Update library `(scheme r4rs)` to export `call/cc`
 instead of `call/cc!`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md               |  6 +++---
 VERSION                 |  2 +-
 basis/r4rs-essential.ss |  4 ++--
 basis/r4rs.ss           |  2 +-
 basis/r5rs.ss           | 12 ++++++------
 test/r4rs.ss            |  2 --
 6 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 915974185..77d1cd1be 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.114.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.115.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.114_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.115_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.114
+Meevax Lisp System, version 0.4.115
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index c027bee4e..9c38b18fd 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.114
+0.4.115
diff --git a/basis/r4rs-essential.ss b/basis/r4rs-essential.ss
index f613ad626..6b893bd8f 100644
--- a/basis/r4rs-essential.ss
+++ b/basis/r4rs-essential.ss
@@ -11,7 +11,7 @@
           (meevax read)
           (meevax string)
           (meevax symbol)
-          (meevax syntax)
+          (rename (meevax syntax) (call-with-current-continuation! call-with-current-continuation))
           (meevax vector)
           (meevax write)
           (srfi 211 explicit-renaming))
@@ -34,7 +34,7 @@
           string-ci=? string-ci<? string-ci>? string-ci<=? string-ci>=?
           substring string-append string->list list->string vector? make-vector
           vector vector-length vector-ref vector-set! vector->list list->vector
-          procedure? apply map for-each call-with-current-continuation!
+          procedure? apply map for-each call-with-current-continuation
           call-with-input-file call-with-output-file input-port? output-port?
           current-input-port current-output-port open-input-file
           open-output-file close-input-port close-output-port read read-char
diff --git a/basis/r4rs.ss b/basis/r4rs.ss
index 617494b67..86712c318 100644
--- a/basis/r4rs.ss
+++ b/basis/r4rs.ss
@@ -32,7 +32,7 @@
           string-append string->list list->string string-copy string-fill!
           vector? make-vector vector vector-length vector-ref vector-set!
           vector->list list->vector vector-fill! procedure? apply map for-each
-          force call-with-current-continuation! call-with-input-file
+          force call-with-current-continuation call-with-input-file
           call-with-output-file input-port? output-port? current-input-port
           current-output-port with-input-from-file with-output-to-file
           open-input-file open-output-file close-input-port close-output-port
diff --git a/basis/r5rs.ss b/basis/r5rs.ss
index 9adbf9d6e..28b7364b7 100644
--- a/basis/r5rs.ss
+++ b/basis/r5rs.ss
@@ -1,7 +1,7 @@
 (define-library (scheme r5rs continuation)
   (import (meevax context)
           (only (meevax syntax) define-syntax)
-          (scheme r4rs essential))
+          (rename (scheme r4rs) (call-with-current-continuation r4rs:call/cc)))
 
   (export call-with-current-continuation dynamic-wind exit)
 
@@ -25,10 +25,10 @@
                    (else ((cdar from)) (windup! (cdr from) (cdr to)) ((caar to))))
              (set! %current-dynamic-extents to))
            (let ((current-dynamic-extents %current-dynamic-extents))
-             (call-with-current-continuation! (lambda (k1)
-                                                (procedure (lambda (k2)
-                                                             (windup! %current-dynamic-extents current-dynamic-extents)
-                                                             (k1 k2)))))))
+             (r4rs:call/cc (lambda (k1)
+                             (procedure (lambda (k2)
+                                          (windup! %current-dynamic-extents current-dynamic-extents)
+                                          (k1 k2)))))))
 
          (define (exit . normally?)
            (for-each (lambda (before/after)
@@ -40,7 +40,7 @@
   (import (meevax environment)
           (meevax evaluate)
           (only (meevax syntax) define-syntax let-syntax letrec-syntax)
-          (except (scheme r4rs) call-with-current-continuation!)
+          (except (scheme r4rs) call-with-current-continuation)
           (except (scheme r5rs continuation) exit)
           (srfi 149))
 
diff --git a/test/r4rs.ss b/test/r4rs.ss
index 5ebe9d73c..e72cf86c5 100644
--- a/test/r4rs.ss
+++ b/test/r4rs.ss
@@ -2,8 +2,6 @@
         (scheme process-context)
         (srfi 78))
 
-(define call-with-current-continuation call-with-current-continuation!) ; TEMPORARY
-
 (check (* 5 8) => 40)
 
 ;;; The FACT procedure computes the factorial

From 0264180cf3bfd76f47f7d91ae7a362dbf9137f62 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 10 Jul 2022 00:01:49 +0900
Subject: [PATCH 35/36] Move builtin library declarations into `library::boot`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 CMakeLists.txt                    |    4 +-
 README.md                         |    6 +-
 VERSION                           |    2 +-
 include/meevax/kernel/library.hpp |   34 +-
 src/kernel/library.cpp            | 2049 +++++++++++++++--------------
 5 files changed, 1103 insertions(+), 992 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 32eeb1563..55b220733 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,11 +19,11 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_VERBOSE_MAKEFILE OFF)
 
-set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -Wno-parentheses")
+set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -Wno-parentheses -pipe")
 set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g")
 set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os    -DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
-set(CMAKE_CXX_FLAGS_RELEASE        "-O3    -DNDEBUG -pipe") # NOTE: -march=native causes "Illegal instruction" error (is Valgrind's bug) on CI.
+set(CMAKE_CXX_FLAGS_RELEASE        "-O3    -DNDEBUG") # NOTE: -march=native causes "Illegal instruction" error (is Valgrind's bug) on CI.
 
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})
diff --git a/README.md b/README.md
index 77d1cd1be..c22882958 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.115.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.116.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.115_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.116_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.115
+Meevax Lisp System, version 0.4.116
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 9c38b18fd..6a8693646 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.115
+0.4.116
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 57f45e8b8..adc5ab031 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -36,7 +36,7 @@ inline namespace kernel
     template <typename Build, REQUIRES(std::is_invocable<Build, library &>)>
     explicit library(Build&& build)
     {
-      build(*this);
+      std::invoke(std::forward<decltype(build)>(build), *this);
     }
 
     explicit library(const_reference);
@@ -52,38 +52,6 @@ inline namespace kernel
     auto export_(external_representation const&) -> void;
 
     auto resolve() -> const_reference;
-
-    #define DEFINE_BASIS_LIBRARY(NAME)                                         \
-    struct NAME##_library_t                                                    \
-    {                                                                          \
-      explicit NAME##_library_t() = default;                                   \
-    }                                                                          \
-    static constexpr NAME##_library {};                                        \
-                                                                               \
-    explicit library(NAME##_library_t)
-
-    DEFINE_BASIS_LIBRARY(character);
-    DEFINE_BASIS_LIBRARY(context);
-    DEFINE_BASIS_LIBRARY(control);
-    DEFINE_BASIS_LIBRARY(environment);
-    DEFINE_BASIS_LIBRARY(equivalence);
-    DEFINE_BASIS_LIBRARY(evaluate);
-    DEFINE_BASIS_LIBRARY(exception);
-    DEFINE_BASIS_LIBRARY(experimental);
-    DEFINE_BASIS_LIBRARY(inexact);
-    DEFINE_BASIS_LIBRARY(list);
-    DEFINE_BASIS_LIBRARY(macro);
-    DEFINE_BASIS_LIBRARY(number);
-    DEFINE_BASIS_LIBRARY(pair);
-    DEFINE_BASIS_LIBRARY(port);
-    DEFINE_BASIS_LIBRARY(read);
-    DEFINE_BASIS_LIBRARY(string);
-    DEFINE_BASIS_LIBRARY(symbol);
-    DEFINE_BASIS_LIBRARY(syntax);
-    DEFINE_BASIS_LIBRARY(vector);
-    DEFINE_BASIS_LIBRARY(write);
-
-    #undef DEFINE_BASIS_LIBRARY
   };
 
   auto operator <<(std::ostream &, library const&) -> std::ostream &;
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index c3847297e..17d695a8e 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -22,1185 +22,1297 @@ namespace meevax
 {
 inline namespace kernel
 {
-  library::library(syntax_library_t)
-  {
-    define<syntax>("begin", machine::begin);
-    define<syntax>("call-with-current-continuation!", call_with_current_continuation);
-    define<syntax>("define", machine::define);
-    define<syntax>("define-syntax", define_syntax);
-    define<syntax>("if", if_);
-    define<syntax>("lambda", lambda);
-    define<syntax>("let-syntax", let_syntax);
-    define<syntax>("letrec", letrec);
-    define<syntax>("letrec-syntax", letrec_syntax);
-    define<syntax>("quote", quote);
-    define<syntax>("quote-syntax", quote_syntax);
-    define<syntax>("set!", set);
-
-    export_("begin");
-    export_("call-with-current-continuation!");
-    export_("define");
-    export_("define-syntax");
-    export_("if");
-    export_("lambda");
-    export_("let-syntax");
-    export_("letrec");
-    export_("letrec-syntax");
-    export_("quote");
-    export_("quote-syntax");
-    export_("set!");
-  }
+  library::library(const_reference declarations)
+    : declarations { declarations }
+  {}
 
-  library::library(environment_library_t)
+  auto library::boot() -> void
   {
-    define<procedure>("environment", [](let const& xs)
+    define_library("(meevax character)", [](library & library)
     {
-      let const e = make<environment>();
+      library.define<predicate>("char?", [](let const& xs)
+      {
+        return car(xs).is<character>();
+      });
 
-      for (let const& x : xs)
+      library.define<procedure>("char->integer", [](let const& xs)
       {
-        e.as<environment>().import_(x);
-      }
+        if (xs.is<pair>() and car(xs).is<character>())
+        {
+          return make<exact_integer>(car(xs).as<character>().codepoint);
+        }
+        else
+        {
+          throw invalid_application(intern("char->integer") | xs);
+        }
+      });
 
-      return e;
-    });
+      library.define<procedure>("char-codepoint", [](let const& xs) -> value_type
+      {
+        if (auto c = car(xs).as<character>(); std::isdigit(c.codepoint))
+        {
+          return make<exact_integer>(c.codepoint - '0');
+        }
+        else
+        {
+          return f;
+        }
+      });
 
-    define<procedure>("%load", [](let const& xs)
-    {
-      return car(xs).as<environment>().load(cadr(xs).as<string>());
+      library.export_("char?");
+      library.export_("char->integer");
+      library.export_("char-codepoint");
     });
 
-    define<procedure>("interaction-environment", [](auto&&...)
+    define_library("(meevax context)", [](library & library)
     {
-      return interaction_environment();
-    });
-
-    export_("environment");
-    export_("interaction-environment");
-    export_("%load");
-  }
-
-  library::library(equivalence_library_t)
-  {
-    define<predicate>("eq?",  [](let const& xs) { return eq (car(xs), cadr(xs)); });
-    define<predicate>("eqv?", [](let const& xs) { return eqv(car(xs), cadr(xs)); });
-
-    export_("eq?");
-    export_("eqv?");
-  }
+      library.define<procedure>("emergency-exit", [](let const& xs) -> value_type
+      {
+        switch (length(xs))
+        {
+        case 0:
+          throw exit_status::success;
+
+        case 1:
+          if (let const& x = car(xs); x.is<bool>())
+          {
+            throw select(x) ? exit_status::success : exit_status::failure;
+          }
+          else if (x.is<exact_integer>())
+          {
+            throw exit_status(static_cast<int>(x.as<exact_integer>()));
+          }
+          else [[fallthrough]];
+
+        default:
+          throw invalid_application(intern("emergency-exit") | xs);
+        }
+      });
 
-  library::library(number_library_t)
-  {
-    define<predicate>("number?",        [](let const& xs) { return car(xs).is_also<number>(); });
-    define<predicate>("complex?",       [](let const& xs) { return car(xs).is_also<number>() and car(xs).as<number>().is_complex (); });
-    define<predicate>("real?",          [](let const& xs) { return car(xs).is_also<number>() and car(xs).as<number>().is_real    (); });
-    define<predicate>("rational?",      [](let const& xs) { return car(xs).is_also<number>() and car(xs).as<number>().is_rational(); });
-    define<predicate>("integer?",       [](let const& xs) { return car(xs).is_also<number>() and car(xs).as<number>().is_integer (); });
-    define<predicate>("exact-integer?", [](let const& xs) { return car(xs).is<exact_integer>(); });
-    define<predicate>("%complex?",      [](let const& xs) { return car(xs).is<complex      >(); });
-    define<predicate>("ratio?",         [](let const& xs) { return car(xs).is<ratio        >(); });
-    define<predicate>("single-float?",  [](let const& xs) { return car(xs).is<single_float >(); });
-    define<predicate>("double-float?",  [](let const& xs) { return car(xs).is<double_float >(); });
-
-    #define DEFINE(SYMBOL, COMPARE)                                            \
-    define<predicate>(#SYMBOL, [](let const& xs)                               \
-    {                                                                          \
-      return std::adjacent_find(                                               \
-               std::begin(xs), std::end(xs), [](let const& a, let const& b)    \
-               {                                                               \
-                 return not COMPARE(a.as<number>(), b);                        \
-               }) == std::end(xs);                                             \
-    })
-
-    DEFINE(= , std::equal_to     <void>());
-    DEFINE(!=, std::not_equal_to <void>());
-    DEFINE(< , std::less         <void>());
-    DEFINE(<=, std::less_equal   <void>());
-    DEFINE(> , std::greater      <void>());
-    DEFINE(>=, std::greater_equal<void>());
-
-    #undef DEFINE
-
-    define<procedure>("+", [](let const& xs) { return std::accumulate(std::begin(xs), std::end(xs), e0, std::plus<void>()); });
-    define<procedure>("*", [](let const& xs) { return std::accumulate(std::begin(xs), std::end(xs), e1, std::multiplies<void>()); });
-
-    #define DEFINE(SYMBOL, FUNCTION, BASIS)                                    \
-    define<procedure>(SYMBOL, [](let const& xs)                                \
-    {                                                                          \
-      switch (length(xs))                                                      \
-      {                                                                        \
-      case 0:                                                                  \
-        throw invalid_application(intern(SYMBOL) | xs);                        \
-                                                                               \
-      case 1:                                                                  \
-        return FUNCTION(BASIS, car(xs));                                       \
-                                                                               \
-      default:                                                                 \
-        return std::accumulate(                                                \
-                 std::next(std::begin(xs)), std::end(xs), car(xs),             \
-                 [](let const& a, let const& b)                                \
-                 {                                                             \
-                   return FUNCTION(a, b);                                      \
-                 });                                                           \
-      }                                                                        \
-    })
-
-    DEFINE("-", sub, e0);
-    DEFINE("/", div, e1);
-    DEFINE("%", mod, e1);
-
-    #undef DEFINE
-
-    define<procedure>("floor",    [](let const& xs) { return car(xs).as<number>().floor  (); });
-    define<procedure>("ceiling",  [](let const& xs) { return car(xs).as<number>().ceil   (); });
-    define<procedure>("truncate", [](let const& xs) { return car(xs).as<number>().trunc  (); });
-    define<procedure>("round",    [](let const& xs) { return car(xs).as<number>().round  (); });
-
-    define<procedure>("exact",    [](let const& xs) { return car(xs).as<number>().exact  (); });
-    define<procedure>("inexact",  [](let const& xs) { return car(xs).as<number>().inexact(); });
-
-    define<procedure>("expt", [](let const& xs)
-    {
-      return car(xs).as<number>().pow(cadr(xs));
+      library.export_("emergency-exit");
     });
 
-    define<procedure>("integer->char", [](let const& xs)
+    define_library("(meevax control)", [](library & library)
     {
-      if (xs.is<pair>() and car(xs).is<exact_integer>())
+      library.define<predicate>("closure?", [](let const& xs)
       {
-        return make<character>(static_cast<character::value_type>(car(xs).as<exact_integer>()));
-      }
-      else
+        return car(xs).is<closure>();
+      });
+
+      library.define<predicate>("continuation?", [](let const& xs)
       {
-        throw invalid_application(intern("integer->char") | xs);
-      }
-    });
+        return car(xs).is<continuation>();
+      });
 
-    define<procedure>("number->string", [](auto&& xs)
-    {
-      return make<string>(lexical_cast<external_representation>(car(xs)));
+      library.export_("closure?");
+      library.export_("continuation?");
     });
 
-    export_("number?");
-    export_("complex?");
-    export_("real?");
-    export_("rational?");
-    export_("integer?");
-    export_("exact-integer?");
-    export_("%complex?");
-    export_("ratio?");
-    export_("single-float?");
-    export_("double-float?");
-    export_("=");
-    export_("!=");
-    export_("<");
-    export_("<=");
-    export_(">");
-    export_(">=");
-    export_("+");
-    export_("*");
-    export_("-");
-    export_("/");
-    export_("%");
-    export_("floor");
-    export_("ceiling");
-    export_("truncate");
-    export_("round");
-    export_("expt");
-    export_("exact");
-    export_("inexact");
-    export_("integer->char");
-    export_("number->string");
-  }
-
-  library::library(inexact_library_t)
-  {
-    define<predicate>("finite?",   [](let const& xs) { return car(xs).as<number>().is_finite  (); });
-    define<predicate>("infinite?", [](let const& xs) { return car(xs).as<number>().is_infinite(); });
-
-    define<predicate>("nan?", [](let const& xs)
+    define_library("(meevax environment)", [](library & library)
     {
-      return car(xs).is_also<number>() and car(xs).as<number>().is_nan();
-    });
+      library.define<procedure>("environment", [](let const& xs)
+      {
+        let const e = make<environment>();
+
+        for (let const& x : xs)
+        {
+          e.as<environment>().import_(x);
+        }
 
-    define<procedure>("exp",  [](let const& xs) { return car(xs).as<number>().exp();  });
-    define<procedure>("sqrt", [](let const& xs) { return car(xs).as<number>().sqrt(); });
+        return e;
+      });
 
-    define<procedure>("log", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("%load", [](let const& xs)
       {
-      case 1:
-        return car(xs).as<number>().log();
+        return car(xs).as<environment>().load(cadr(xs).as<string>());
+      });
 
-      case 2:
-        return car(xs).as<number>().log() / cadr(xs).as<number>().log();
+      library.define<procedure>("interaction-environment", [](auto&&...)
+      {
+        return interaction_environment();
+      });
 
-      default:
-        throw invalid_application(intern("log") | xs);
-      }
+      library.export_("environment");
+      library.export_("interaction-environment");
+      library.export_("%load");
     });
 
-    define<procedure>("sin",   [](let const& xs) { return car(xs).as<number>().sin();   });
-    define<procedure>("cos",   [](let const& xs) { return car(xs).as<number>().cos();   });
-    define<procedure>("tan",   [](let const& xs) { return car(xs).as<number>().tan();   });
-    define<procedure>("asin",  [](let const& xs) { return car(xs).as<number>().asin();  });
-    define<procedure>("acos",  [](let const& xs) { return car(xs).as<number>().acos();  });
-    define<procedure>("sinh",  [](let const& xs) { return car(xs).as<number>().sinh();  });
-    define<procedure>("cosh",  [](let const& xs) { return car(xs).as<number>().cosh();  });
-    define<procedure>("tanh",  [](let const& xs) { return car(xs).as<number>().tanh();  });
-    define<procedure>("asinh", [](let const& xs) { return car(xs).as<number>().asinh(); });
-    define<procedure>("acosh", [](let const& xs) { return car(xs).as<number>().acosh(); });
-    define<procedure>("atanh", [](let const& xs) { return car(xs).as<number>().atanh(); });
-
-    define<procedure>("atan", [](let const& xs)
+    define_library("(meevax equivalence)", [](library & library)
     {
-      switch (length(xs))
-      {
-      case 1:
-        return car(xs).as<number>().atan();
-
-      case 2:
-        return car(xs).as<number>().atan2(cadr(xs));
+      library.define<predicate>("eq?",  [](let const& xs) { return eq (car(xs), cadr(xs)); });
+      library.define<predicate>("eqv?", [](let const& xs) { return eqv(car(xs), cadr(xs)); });
 
-      default:
-        throw invalid_application(intern("atan") | xs);
-      }
+      library.export_("eq?");
+      library.export_("eqv?");
     });
 
-    export_("finite?");
-    export_("infinite?");
-    export_("nan?");
-    export_("exp");
-    export_("sqrt");
-    export_("log");
-    export_("sin");
-    export_("asin");
-    export_("sinh");
-    export_("asinh");
-    export_("cos");
-    export_("acos");
-    export_("cosh");
-    export_("acosh");
-    export_("tan");
-    export_("atan");
-    export_("tanh");
-    export_("atanh");
-  }
-
-  library::library(pair_library_t)
-  {
-    define<predicate>("pair?", [](let const& xs)
+    define_library("(meevax evaluate)", [](library & library)
     {
-      return car(xs).is<pair>();
+      library.define<procedure>("eval", [](let const& xs)
+      {
+        return cadr(xs).as<environment>().evaluate(car(xs));
+      });
+
+      library.export_("eval");
     });
 
-    define<intrinsic>("cons", cons_, [](let const& xs)
+    define_library("(meevax exception)", [](library & library)
     {
-      return cons(car(xs), cadr(xs));
-    });
+      library.define<procedure>("throw", [](let const& xs) -> value_type
+      {
+        throw car(xs);
+      });
 
-    define<procedure>("car", [](let const& xs) { return caar(xs); });
-    define<procedure>("cdr", [](let const& xs) { return cdar(xs); });
-
-    define<procedure>("caar", [](let const& xs) { return caar(car(xs)); });
-    define<procedure>("cadr", [](let const& xs) { return cadr(car(xs)); });
-    define<procedure>("cdar", [](let const& xs) { return cdar(car(xs)); });
-    define<procedure>("cddr", [](let const& xs) { return cddr(car(xs)); });
-
-    define<procedure>("caaar", [](let const& xs) { return caaar(car(xs)); });
-    define<procedure>("caadr", [](let const& xs) { return caadr(car(xs)); });
-    define<procedure>("cadar", [](let const& xs) { return cadar(car(xs)); });
-    define<procedure>("caddr", [](let const& xs) { return caddr(car(xs)); });
-    define<procedure>("cdaar", [](let const& xs) { return cdaar(car(xs)); });
-    define<procedure>("cdadr", [](let const& xs) { return cdadr(car(xs)); });
-    define<procedure>("cddar", [](let const& xs) { return cddar(car(xs)); });
-    define<procedure>("cdddr", [](let const& xs) { return cdddr(car(xs)); });
-
-    define<procedure>("caaaar", [](let const& xs) { return caaaar(car(xs)); });
-    define<procedure>("caaadr", [](let const& xs) { return caaadr(car(xs)); });
-    define<procedure>("caadar", [](let const& xs) { return caadar(car(xs)); });
-    define<procedure>("caaddr", [](let const& xs) { return caaddr(car(xs)); });
-    define<procedure>("cadaar", [](let const& xs) { return cadaar(car(xs)); });
-    define<procedure>("cadadr", [](let const& xs) { return cadadr(car(xs)); });
-    define<procedure>("caddar", [](let const& xs) { return caddar(car(xs)); });
-    define<procedure>("cadddr", [](let const& xs) { return cadddr(car(xs)); });
-    define<procedure>("cdaaar", [](let const& xs) { return cdaaar(car(xs)); });
-    define<procedure>("cdaadr", [](let const& xs) { return cdaadr(car(xs)); });
-    define<procedure>("cdadar", [](let const& xs) { return cdadar(car(xs)); });
-    define<procedure>("cdaddr", [](let const& xs) { return cdaddr(car(xs)); });
-    define<procedure>("cddaar", [](let const& xs) { return cddaar(car(xs)); });
-    define<procedure>("cddadr", [](let const& xs) { return cddadr(car(xs)); });
-    define<procedure>("cdddar", [](let const& xs) { return cdddar(car(xs)); });
-    define<procedure>("cddddr", [](let const& xs) { return cddddr(car(xs)); });
-
-    define<procedure>("set-car!", [](auto&& xs) { return caar(xs) = cadr(xs); });
-    define<procedure>("set-cdr!", [](auto&& xs) { return cdar(xs) = cadr(xs); });
-
-    export_("pair?");
-    export_("cons");
-    export_("car");
-    export_("cdr");
-    export_("set-car!");
-    export_("set-cdr!");
-    export_("caaaar");
-    export_("caaadr");
-    export_("caaar");
-    export_("caadar");
-    export_("caaddr");
-    export_("caadr");
-    export_("caar");
-    export_("cadaar");
-    export_("cadadr");
-    export_("cadar");
-    export_("caddar");
-    export_("cadddr");
-    export_("caddr");
-    export_("cadr");
-    export_("cdaaar");
-    export_("cdaadr");
-    export_("cdaar");
-    export_("cdadar");
-    export_("cdaddr");
-    export_("cdadr");
-    export_("cdar");
-    export_("cddaar");
-    export_("cddadr");
-    export_("cddar");
-    export_("cdddar");
-    export_("cddddr");
-    export_("cdddr");
-    export_("cddr");
-  }
+      library.define<procedure>("make-error", [](let const& xs)
+      {
+        return make<error>(car(xs), cdr(xs));
+      });
 
-  library::library(list_library_t)
-  {
-    define<predicate>("null?", [](let const& xs)
-    {
-      return car(xs).is<null>();
-    });
+      library.define<predicate>("error?", [](let const& xs)
+      {
+        return car(xs).is<error>();
+      });
 
-    define<procedure>("append", [](let const& xs)
-    {
-      return std::accumulate(std::begin(xs), std::end(xs), unit, append2);
-    });
+      library.define<predicate>("read-error?", [](let const& xs)
+      {
+        return car(xs).is<read_error>();
+      });
 
-    define<procedure>("list->string", [](let const& xs)
-    {
-      string s;
+      library.define<predicate>("file-error?", [](let const& xs)
+      {
+        return car(xs).is<file_error>();
+      });
 
-      for (let const& x : car(xs))
+      library.define<predicate>("syntax-error?", [](let const& xs)
       {
-        s.push_back(x.as<character>());
-      }
+        return car(xs).is<syntax_error>();
+      });
 
-      return make(std::move(s));
+      library.export_("throw");
+      library.export_("make-error");
+      library.export_("error?");
+      library.export_("read-error?");
+      library.export_("file-error?");
+      library.export_("syntax-error?");
     });
 
-    define<procedure>("list->vector", [](let const& xs)
+    define_library("(meevax experimental)", [](library & library)
     {
-      return make<vector>(car(xs));
-    });
+      library.define<procedure>("type-of", [](let const& xs)
+      {
+        std::cout << car(xs).type().name() << std::endl;
+        return standard_output;
+      });
 
-    export_("null?");
-    export_("append");
-    export_("list->string");
-    export_("list->vector");
-  }
+      library.define<procedure>("disassemble", [](let const& xs)
+      {
+        if (0 < length(xs))
+        {
+          if (let const& f = car(xs); f.is<closure>())
+          {
+            disassemble(std::cout, car(f));
+          }
+        }
 
-  library::library(symbol_library_t)
-  {
-    define<predicate>("symbol?", [](let const& xs)
-    {
-      return car(xs).is<symbol>();
+        return standard_output;
+      });
+
+      library.define<predicate>("ieee-float?", [](auto&&...)
+      {
+        return std::numeric_limits<double>::is_iec559;
+      });
+
+      library.export_("type-of");
+      library.export_("disassemble");
+      library.export_("ieee-float?");
     });
 
-    define<procedure>("symbol->string", [](let const& xs)
+    define_library("(meevax foreign-function)", [](library & library)
     {
-      return make<string>(car(xs).as<symbol>());
-    });
+      library.define<procedure>("foreign-function", [](let const& xs)
+      {
+        return make<procedure>(cadr(xs).as<string>(), car(xs).as<string>());
+      });
 
-    export_("symbol?");
-    export_("symbol->string");
-  }
+      library.define<predicate>("foreign-function?", [](let const& xs)
+      {
+        return car(xs).is<procedure>();
+      });
 
-  library::library(character_library_t)
-  {
-    define<predicate>("char?", [](let const& xs)
-    {
-      return car(xs).is<character>();
+      library.export_("foreign-function");
+      library.export_("foreign-function?");
     });
 
-    define<procedure>("char->integer", [](let const& xs)
+    define_library("(meevax garbage-collector)", [](library & library)
     {
-      if (xs.is<pair>() and car(xs).is<character>())
+      library.define<procedure>("gc-collect", [](auto&&...)
       {
-        return make<exact_integer>(car(xs).as<character>().codepoint);
-      }
-      else
+        return make<exact_integer>(gc.collect());
+      });
+
+      library.define<procedure>("gc-count", [](auto&&...)
       {
-        throw invalid_application(intern("char->integer") | xs);
-      }
+        return make<exact_integer>(gc.count());
+      });
+
+      library.export_("gc-collect");
+      library.export_("gc-count");
     });
 
-    define<procedure>("char-codepoint", [](let const& xs) -> value_type
+    define_library("(meevax inexact)", [](library & library)
     {
-      if (auto c = car(xs).as<character>(); std::isdigit(c.codepoint))
+      library.define<predicate>("finite?", [](let const& xs)
       {
-        return make<exact_integer>(c.codepoint - '0');
-      }
-      else
+        return car(xs).as<number>().is_finite();
+      });
+
+      library.define<predicate>("infinite?", [](let const& xs)
       {
-        return f;
-      }
-    });
+        return car(xs).as<number>().is_infinite();
+      });
 
-    export_("char?");
-    export_("char->integer");
-    export_("char-codepoint");
-  }
+      library.define<predicate>("nan?", [](let const& xs)
+      {
+        return car(xs).is_also<number>() and car(xs).as<number>().is_nan();
+      });
 
-  library::library(string_library_t)
-  {
-    define<predicate>("string?", [](let const& xs) { return car(xs).is<string>(); });
+      library.define<procedure>("exp", [](let const& xs)
+      {
+        return car(xs).as<number>().exp();
+      });
 
-    define<procedure>("make-string", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("sqrt", [](let const& xs)
       {
-      case 1:
-        return make<string>(static_cast<string::size_type>(car(xs).as<exact_integer>()), character());
+        return car(xs).as<number>().sqrt();
+      });
 
-      case 2:
-        return make<string>(static_cast<string::size_type>(car(xs).as<exact_integer>()), cadr(xs).as<character>());
+      library.define<procedure>("log", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 1:
+          return car(xs).as<number>().log();
 
-      default:
-        throw invalid_application(intern("make-string") | xs);
-      }
-    });
+        case 2:
+          return car(xs).as<number>().log() / cadr(xs).as<number>().log();
 
-    define<procedure>("string-length", [](let const& xs)
-    {
-      return make<exact_integer>(car(xs).as<string>().size());
-    });
+        default:
+          throw invalid_application(intern("log") | xs);
+        }
+      });
 
-    define<procedure>("string-ref", [](let const& xs)
-    {
-      return make(car(xs).as<string>().at(static_cast<string::size_type>(cadr(xs).as<exact_integer>())));
-    });
+      library.define<procedure>("sin", [](let const& xs)
+      {
+        return car(xs).as<number>().sin();
+      });
 
-    define<procedure>("string-set!", [](let const& xs)
-    {
-      car(xs).as<string>().at(static_cast<string::size_type>(cadr(xs).as<exact_integer>())) = caddr(xs).as<character>();
-      return car(xs);
-    });
+      library.define<procedure>("cos", [](let const& xs)
+      {
+        return car(xs).as<number>().cos();
+      });
 
-    define<procedure>("string-append", [](let const& xs)
-    {
-      string result;
+      library.define<procedure>("tan", [](let const& xs)
+      {
+        return car(xs).as<number>().tan();
+      });
 
-      for (let const& x : xs)
+      library.define<procedure>("asin", [](let const& xs)
       {
-        std::copy(std::cbegin(x.as<string>()), std::cend(x.as<string>()), std::back_inserter(result));
-      }
+        return car(xs).as<number>().asin();
+      });
 
-      return make(result);
-    });
+      library.define<procedure>("acos", [](let const& xs)
+      {
+        return car(xs).as<number>().acos();
+      });
 
-    define<procedure>("string-copy", [](let const& xs)
-    {
-      switch (length(xs))
-      {
-      case 1:
-        return make<string>(car(xs).as<string>());
-
-      case 2:
-        return make<string>(car(xs).as<string>().begin() + static_cast<string::size_type>(cadr(xs).as<exact_integer>()),
-                            car(xs).as<string>().end());
-      case 3:
-        return make<string>(car(xs).as<string>().begin() + static_cast<string::size_type>( cadr(xs).as<exact_integer>()),
-                            car(xs).as<string>().begin() + static_cast<string::size_type>(caddr(xs).as<exact_integer>()));
-      default:
-        throw invalid_application(intern("string-copy") | xs);
-      }
-    });
+      library.define<procedure>("atan", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 1:
+          return car(xs).as<number>().atan();
 
-    #define STRING_COMPARE(COMPARE)                                            \
-    [](let const& xs)                                                          \
-    {                                                                          \
-      return std::adjacent_find(                                               \
-               std::begin(xs), std::end(xs), [](let const& a, let const& b)    \
-               {                                                               \
-                 return not COMPARE(a.as_const<string>(),                      \
-                                    b.as_const<string>());                     \
-               }) == std::end(xs);                                             \
-    }
+        case 2:
+          return car(xs).as<number>().atan2(cadr(xs));
 
-    define<predicate>("string=?",  STRING_COMPARE(std::equal_to     <void>()));
-    define<predicate>("string<?",  STRING_COMPARE(std::less         <void>()));
-    define<predicate>("string<=?", STRING_COMPARE(std::less_equal   <void>()));
-    define<predicate>("string>?",  STRING_COMPARE(std::greater      <void>()));
-    define<predicate>("string>=?", STRING_COMPARE(std::greater_equal<void>()));
+        default:
+          throw invalid_application(intern("atan") | xs);
+        }
+      });
 
-    #undef STRING_COMPARE
+      library.define<procedure>("sinh", [](let const& xs)
+      {
+        return car(xs).as<number>().sinh();
+      });
 
-    define<procedure>("string->number", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("cosh", [](let const& xs)
       {
-      case 1:
-        return string_to::number(car(xs).as<string>(), 10);
+        return car(xs).as<number>().cosh();
+      });
 
-      case 2:
-        return string_to::number(car(xs).as<string>(), static_cast<int>(cadr(xs).as<exact_integer>()));
+      library.define<procedure>("tanh", [](let const& xs)
+      {
+        return car(xs).as<number>().tanh();
+      });
 
-      default:
-        throw invalid_application(intern("string->number") | xs);
-      }
-    });
+      library.define<procedure>("asinh", [](let const& xs)
+      {
+        return car(xs).as<number>().asinh();
+      });
 
-    define<procedure>("string->list", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("acosh", [](let const& xs)
+      {
+        return car(xs).as<number>().acosh();
+      });
+
+      library.define<procedure>("atanh", [](let const& xs)
       {
-      case 1:
-        return car(xs).as<string>().list();
+        return car(xs).as<number>().atanh();
+      });
 
-      case 2:
-        return car(xs).as<string>().list(static_cast<string::size_type>(cadr(xs).as<exact_integer>()));
+      library.export_("finite?");
+      library.export_("infinite?");
+      library.export_("nan?");
+      library.export_("exp");
+      library.export_("sqrt");
+      library.export_("log");
+      library.export_("sin");
+      library.export_("asin");
+      library.export_("sinh");
+      library.export_("asinh");
+      library.export_("cos");
+      library.export_("acos");
+      library.export_("cosh");
+      library.export_("acosh");
+      library.export_("tan");
+      library.export_("atan");
+      library.export_("tanh");
+      library.export_("atanh");
+    });
+
+    define_library("(meevax list)", [](library & library)
+    {
+      library.define<predicate>("null?", [](let const& xs)
+      {
+        return car(xs).is<null>();
+      });
 
-      case 3:
-        return car(xs).as<string>().list(static_cast<string::size_type>(cadr(xs).as<exact_integer>()), static_cast<string::size_type>(caddr(xs).as<exact_integer>()));
+      library.define<procedure>("append", [](let const& xs)
+      {
+        return std::accumulate(std::begin(xs), std::end(xs), unit, append2);
+      });
 
-      default:
-        throw invalid_application(intern("string->list") | xs);
-      }
-    });
+      library.define<procedure>("list->string", [](let const& xs)
+      {
+        string s;
 
-    define<procedure>("string->symbol", [](let const& xs)
-    {
-      return intern(car(xs).as<string>());
-    });
+        for (let const& x : car(xs))
+        {
+          s.push_back(x.as<character>());
+        }
 
-    export_("string?");
-    export_("make-string");
-    export_("string-append");
-    export_("string-copy");
-    export_("string-length");
-    export_("string-ref");
-    export_("string-set!");
-    export_("string=?");
-    export_("string<?");
-    export_("string<=?");
-    export_("string>?");
-    export_("string>=?");
-    export_("string->list");
-    export_("string->number");
-    export_("string->symbol");
-  }
+        return make(std::move(s));
+      });
 
-  library::library(vector_library_t)
-  {
-    define<predicate>("vector?", [](let const& xs)
-    {
-      return car(xs).is<vector>();
-    });
+      library.define<procedure>("list->vector", [](let const& xs)
+      {
+        return make<vector>(car(xs));
+      });
 
-    define<procedure>("vector", [](let const& xs)
-    {
-      return make<vector>(xs);
+      library.export_("null?");
+      library.export_("append");
+      library.export_("list->string");
+      library.export_("list->vector");
     });
 
-    define<procedure>("make-vector", [](let const& xs)
+    define_library("(meevax macro)", [](library & library)
     {
-      switch (length(xs))
+      library.define<predicate>("identifier?", [](let const& xs)
       {
-      case 1:
-        return make<vector>(car(xs), unspecified);
+        return car(xs).is_also<identifier>();
+      });
 
-      case 2:
-        return make<vector>(car(xs), cadr(xs));
+      library.define<procedure>("identifier->symbol", [](let const& xs)
+      {
+        if (let const& x = car(xs); x.is<syntactic_closure>())
+        {
+          return x.as<syntactic_closure>().expression;
+        }
+        else
+        {
+          return x;
+        }
+      });
 
-      default:
-        throw invalid_application(intern("make-vector") | xs);
-      }
-    });
+      library.define<predicate>("transformer?", [](let const& xs)
+      {
+        return car(xs).is_also<transformer>();
+      });
 
-    define<procedure>("vector-length", [](let const& xs)
-    {
-      return car(xs).as<vector>().length();
-    });
+      library.define<predicate>("syntactic-closure?", [](let const& xs)
+      {
+        return car(xs).is<syntactic_closure>();
+      });
 
-    define<procedure>("vector-ref", [](let const& xs)
-    {
-      return car(xs).as<vector>().ref(cadr(xs));
-    });
+      library.define<procedure>("make-syntactic-closure", [](let const& xs)
+      {
+        return make<syntactic_closure>(car(xs), cadr(xs), caddr(xs));
+      });
 
-    define<procedure>("vector-set!", [](let const& xs)
-    {
-      return car(xs).as<vector>().set(cadr(xs), caddr(xs));
+      library.export_("identifier?");
+      library.export_("identifier->symbol");
+      library.export_("transformer?");
+      library.export_("syntactic-closure?");
+      library.export_("make-syntactic-closure");
     });
 
-    define<procedure>("vector-fill!", [](let const& xs)
+    define_library("(meevax number)", [](library & library)
     {
-      switch (length(xs))
+      library.define<predicate>("number?", [](let const& xs)
       {
-      case 2:
-        car(xs).as<vector>().fill(cadr(xs), e0, car(xs).as<vector>().length());
-        break;
-
-      case 3:
-        car(xs).as<vector>().fill(cadr(xs), caddr(xs), car(xs).as<vector>().length());
-        break;
+        return car(xs).is_also<number>();
+      });
 
-      case 4:
-        car(xs).as<vector>().fill(cadr(xs), caddr(xs), cadddr(xs));
-        break;
+      library.define<predicate>("complex?", [](let const& xs)
+      {
+        return car(xs).is_also<number>() and car(xs).as<number>().is_complex();
+      });
 
-      default:
-        throw invalid_application(intern("vector-fill!") | xs);
-      }
+      library.define<predicate>("real?", [](let const& xs)
+      {
+        return car(xs).is_also<number>() and car(xs).as<number>().is_real();
+      });
 
-      return unspecified;
-    });
+      library.define<predicate>("rational?", [](let const& xs)
+      {
+        return car(xs).is_also<number>() and car(xs).as<number>().is_rational();
+      });
 
-    define<procedure>("vector->list", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<predicate>("integer?", [](let const& xs)
       {
-      case 1:
-        return car(xs).as<vector>().list(e0, car(xs).as<vector>().length());
+        return car(xs).is_also<number>() and car(xs).as<number>().is_integer ();
+      });
 
-      case 2:
-        return car(xs).as<vector>().list(cadr(xs), car(xs).as<vector>().length());
+      library.define<predicate>("exact-integer?", [](let const& xs)
+      {
+        return car(xs).is<exact_integer>();
+      });
 
-      case 3:
-        return car(xs).as<vector>().list(cadr(xs), caddr(xs));
+      library.define<predicate>("%complex?", [](let const& xs)
+      {
+        return car(xs).is<complex>();
+      });
 
-      default:
-        throw invalid_application(intern("vector->list") | xs);
-      }
-    });
+      library.define<predicate>("ratio?", [](let const& xs)
+      {
+        return car(xs).is<ratio>();
+      });
 
-    define<procedure>("vector->string", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<predicate>("single-float?", [](let const& xs)
       {
-      case 1:
-        return car(xs).as<vector>().string(e0, car(xs).as<vector>().length());
+        return car(xs).is<single_float>();
+      });
 
-      case 2:
-        return car(xs).as<vector>().string(cadr(xs), car(xs).as<vector>().length());
+      library.define<predicate>("double-float?", [](let const& xs)
+      {
+        return car(xs).is<double_float>();
+      });
 
-      case 3:
-        return car(xs).as<vector>().string(cadr(xs), caddr(xs));
+      #define DEFINE(SYMBOL, COMPARE)                                            \
+      library.define<predicate>(#SYMBOL, [](let const& xs)                       \
+      {                                                                          \
+        return std::adjacent_find(                                               \
+                 std::begin(xs), std::end(xs), [](let const& a, let const& b)    \
+                 {                                                               \
+                   return not COMPARE(a.as<number>(), b);                        \
+                 }) == std::end(xs);                                             \
+      })
+
+      DEFINE(= , std::equal_to     <void>());
+      DEFINE(!=, std::not_equal_to <void>());
+      DEFINE(< , std::less         <void>());
+      DEFINE(<=, std::less_equal   <void>());
+      DEFINE(> , std::greater      <void>());
+      DEFINE(>=, std::greater_equal<void>());
+
+      #undef DEFINE
+
+      library.define<procedure>("+", [](let const& xs)
+      {
+        return std::accumulate(std::begin(xs), std::end(xs), e0, std::plus<void>());
+      });
 
-      default:
-        throw invalid_application(intern("vector->string") | xs);
-      }
-    });
+      library.define<procedure>("*", [](let const& xs)
+      {
+        return std::accumulate(std::begin(xs), std::end(xs), e1, std::multiplies<void>());
+      });
 
-    export_("vector?");
-    export_("vector");
-    export_("make-vector");
-    export_("vector-length");
-    export_("vector-ref");
-    export_("vector-set!");
-    export_("vector-fill!");
-    export_("vector->list");
-    export_("vector->string");
-  }
+      #define DEFINE(SYMBOL, FUNCTION, BASIS)                                    \
+      library.define<procedure>(SYMBOL, [](let const& xs)                        \
+      {                                                                          \
+        switch (length(xs))                                                      \
+        {                                                                        \
+        case 0:                                                                  \
+          throw invalid_application(intern(SYMBOL) | xs);                        \
+                                                                                 \
+        case 1:                                                                  \
+          return FUNCTION(BASIS, car(xs));                                       \
+                                                                                 \
+        default:                                                                 \
+          return std::accumulate(                                                \
+                   std::next(std::begin(xs)), std::end(xs), car(xs),             \
+                   [](let const& a, let const& b)                                \
+                   {                                                             \
+                     return FUNCTION(a, b);                                      \
+                   });                                                           \
+        }                                                                        \
+      })
+
+      DEFINE("-", sub, e0);
+      DEFINE("/", div, e1);
+      DEFINE("%", mod, e1);
+
+      #undef DEFINE
+
+      library.define<procedure>("floor", [](let const& xs)
+      {
+        return car(xs).as<number>().floor();
+      });
 
-  library::library(control_library_t)
-  {
-    define<predicate>("closure?", [](let const& xs)
-    {
-      return car(xs).is<closure>();
-    });
+      library.define<procedure>("ceiling", [](let const& xs)
+      {
+        return car(xs).as<number>().ceil();
+      });
 
-    define<predicate>("continuation?", [](let const& xs)
-    {
-      return car(xs).is<continuation>();
-    });
+      library.define<procedure>("truncate", [](let const& xs)
+      {
+        return car(xs).as<number>().trunc();
+      });
 
-    export_("closure?");
-    export_("continuation?");
-  }
+      library.define<procedure>("round", [](let const& xs)
+      {
+        return car(xs).as<number>().round();
+      });
 
-  library::library(exception_library_t)
-  {
-    define<procedure>("throw", [](let const& xs) -> value_type
-    {
-      throw car(xs);
-    });
+      library.define<procedure>("exact", [](let const& xs)
+      {
+        return car(xs).as<number>().exact();
+      });
 
-    define<procedure>("make-error", [](let const& xs)
-    {
-      return make<error>(car(xs), cdr(xs));
-    });
+      library.define<procedure>("inexact", [](let const& xs)
+      {
+        return car(xs).as<number>().inexact();
+      });
 
-    define<predicate>("error?", [](let const& xs)
-    {
-      return car(xs).is<error>();
-    });
+      library.define<procedure>("expt", [](let const& xs)
+      {
+        return car(xs).as<number>().pow(cadr(xs));
+      });
 
-    define<predicate>("read-error?", [](let const& xs)
-    {
-      return car(xs).is<read_error>();
-    });
+      library.define<procedure>("integer->char", [](let const& xs)
+      {
+        if (xs.is<pair>() and car(xs).is<exact_integer>())
+        {
+          return make<character>(static_cast<character::value_type>(car(xs).as<exact_integer>()));
+        }
+        else
+        {
+          throw invalid_application(intern("integer->char") | xs);
+        }
+      });
 
-    define<predicate>("file-error?", [](let const& xs)
-    {
-      return car(xs).is<file_error>();
-    });
+      library.define<procedure>("number->string", [](auto&& xs)
+      {
+        return make<string>(lexical_cast<external_representation>(car(xs)));
+      });
 
-    define<predicate>("syntax-error?", [](let const& xs)
-    {
-      return car(xs).is<syntax_error>();
-    });
+      library.export_("number?");
+      library.export_("complex?");
+      library.export_("real?");
+      library.export_("rational?");
+      library.export_("integer?");
+      library.export_("exact-integer?");
+      library.export_("%complex?");
+      library.export_("ratio?");
+      library.export_("single-float?");
+      library.export_("double-float?");
+      library.export_("=");
+      library.export_("!=");
+      library.export_("<");
+      library.export_("<=");
+      library.export_(">");
+      library.export_(">=");
+      library.export_("+");
+      library.export_("*");
+      library.export_("-");
+      library.export_("/");
+      library.export_("%");
+      library.export_("floor");
+      library.export_("ceiling");
+      library.export_("truncate");
+      library.export_("round");
+      library.export_("expt");
+      library.export_("exact");
+      library.export_("inexact");
+      library.export_("integer->char");
+      library.export_("number->string");
+    });
+
+    define_library("(meevax pair)", [](library & library)
+    {
+      library.define<predicate>("pair?", [](let const& xs)
+      {
+        return car(xs).is<pair>();
+      });
 
-    export_("throw");
-    export_("make-error");
-    export_("error?");
-    export_("read-error?");
-    export_("file-error?");
-    export_("syntax-error?");
-  }
+      library.define<intrinsic>("cons", cons_, [](let const& xs)
+      {
+        return cons(car(xs), cadr(xs));
+      });
 
-  library::library(port_library_t)
-  {
-    define<predicate>(  "input-port?", [](let const& xs) { return car(xs).is_also<std::istream>(); });
-    define<predicate>( "output-port?", [](let const& xs) { return car(xs).is_also<std::ostream>(); });
-    define<predicate>( "binary-port?", [](let const&   ) { return false;                           });
-    define<predicate>("textual-port?", [](let const& xs) { return car(xs).is_also<std::ios    >(); });
-    define<predicate>(        "port?", [](let const& xs) { return car(xs).is_also<std::ios    >(); });
+      library.define<procedure>("car", [](let const& xs) { return caar(xs); });
+      library.define<procedure>("cdr", [](let const& xs) { return cdar(xs); });
+
+      library.define<procedure>("caar", [](let const& xs) { return caar(car(xs)); });
+      library.define<procedure>("cadr", [](let const& xs) { return cadr(car(xs)); });
+      library.define<procedure>("cdar", [](let const& xs) { return cdar(car(xs)); });
+      library.define<procedure>("cddr", [](let const& xs) { return cddr(car(xs)); });
+
+      library.define<procedure>("caaar", [](let const& xs) { return caaar(car(xs)); });
+      library.define<procedure>("caadr", [](let const& xs) { return caadr(car(xs)); });
+      library.define<procedure>("cadar", [](let const& xs) { return cadar(car(xs)); });
+      library.define<procedure>("caddr", [](let const& xs) { return caddr(car(xs)); });
+      library.define<procedure>("cdaar", [](let const& xs) { return cdaar(car(xs)); });
+      library.define<procedure>("cdadr", [](let const& xs) { return cdadr(car(xs)); });
+      library.define<procedure>("cddar", [](let const& xs) { return cddar(car(xs)); });
+      library.define<procedure>("cdddr", [](let const& xs) { return cdddr(car(xs)); });
+
+      library.define<procedure>("caaaar", [](let const& xs) { return caaaar(car(xs)); });
+      library.define<procedure>("caaadr", [](let const& xs) { return caaadr(car(xs)); });
+      library.define<procedure>("caadar", [](let const& xs) { return caadar(car(xs)); });
+      library.define<procedure>("caaddr", [](let const& xs) { return caaddr(car(xs)); });
+      library.define<procedure>("cadaar", [](let const& xs) { return cadaar(car(xs)); });
+      library.define<procedure>("cadadr", [](let const& xs) { return cadadr(car(xs)); });
+      library.define<procedure>("caddar", [](let const& xs) { return caddar(car(xs)); });
+      library.define<procedure>("cadddr", [](let const& xs) { return cadddr(car(xs)); });
+      library.define<procedure>("cdaaar", [](let const& xs) { return cdaaar(car(xs)); });
+      library.define<procedure>("cdaadr", [](let const& xs) { return cdaadr(car(xs)); });
+      library.define<procedure>("cdadar", [](let const& xs) { return cdadar(car(xs)); });
+      library.define<procedure>("cdaddr", [](let const& xs) { return cdaddr(car(xs)); });
+      library.define<procedure>("cddaar", [](let const& xs) { return cddaar(car(xs)); });
+      library.define<procedure>("cddadr", [](let const& xs) { return cddadr(car(xs)); });
+      library.define<procedure>("cdddar", [](let const& xs) { return cdddar(car(xs)); });
+      library.define<procedure>("cddddr", [](let const& xs) { return cddddr(car(xs)); });
+
+      library.define<procedure>("set-car!", [](auto&& xs) { return caar(xs) = cadr(xs); });
+      library.define<procedure>("set-cdr!", [](auto&& xs) { return cdar(xs) = cadr(xs); });
+
+      library.export_("pair?");
+      library.export_("cons");
+      library.export_("car");
+      library.export_("cdr");
+      library.export_("set-car!");
+      library.export_("set-cdr!");
+      library.export_("caaaar");
+      library.export_("caaadr");
+      library.export_("caaar");
+      library.export_("caadar");
+      library.export_("caaddr");
+      library.export_("caadr");
+      library.export_("caar");
+      library.export_("cadaar");
+      library.export_("cadadr");
+      library.export_("cadar");
+      library.export_("caddar");
+      library.export_("cadddr");
+      library.export_("caddr");
+      library.export_("cadr");
+      library.export_("cdaaar");
+      library.export_("cdaadr");
+      library.export_("cdaar");
+      library.export_("cdadar");
+      library.export_("cdaddr");
+      library.export_("cdadr");
+      library.export_("cdar");
+      library.export_("cddaar");
+      library.export_("cddadr");
+      library.export_("cddar");
+      library.export_("cdddar");
+      library.export_("cddddr");
+      library.export_("cdddr");
+      library.export_("cddr");
+    });
+
+    define_library("(meevax port)", [](library & library)
+    {
+      library.define<predicate>("input-port?", [](let const& xs)
+      {
+        return car(xs).is_also<std::istream>();
+      });
 
-    define<predicate>("input-port-open?", [](let const& xs)
-    {
-      if (let const& x = car(xs); x.is_also<std::ifstream>())
+      library.define<predicate>("output-port?", [](let const& xs)
       {
-        return x.as<std::ifstream>().is_open();
-      }
-      else
+        return car(xs).is_also<std::ostream>();
+      });
+
+      library.define<predicate>("binary-port?", [](auto&&...)
       {
-        return x.is_also<std::istream>();
-      }
-    });
+        return false;
+      });
 
-    define<predicate>("output-port-open?", [](let const& xs)
-    {
-      if (let const& x = car(xs); x.is_also<std::ofstream>())
+      library.define<predicate>("textual-port?", [](let const& xs)
       {
-        return x.as<std::ofstream>().is_open();
-      }
-      else
+        return car(xs).is_also<std::ios>();
+      });
+
+      library.define<predicate>("port?", [](let const& xs)
       {
-        return x.is_also<std::ostream>();
-      }
-    });
+        return car(xs).is_also<std::ios>();
+      });
 
-    define<procedure>("standard-input-port",  [](auto&&...) { return standard_input;  });
-    define<procedure>("standard-output-port", [](auto&&...) { return standard_output; });
-    define<procedure>("standard-error-port",  [](auto&&...) { return standard_error;  });
+      library.define<predicate>("input-port-open?", [](let const& xs)
+      {
+        if (let const& x = car(xs); x.is_also<std::ifstream>())
+        {
+          return x.as<std::ifstream>().is_open();
+        }
+        else
+        {
+          return x.is_also<std::istream>();
+        }
+      });
+
+      library.define<predicate>("output-port-open?", [](let const& xs)
+      {
+        if (let const& x = car(xs); x.is_also<std::ofstream>())
+        {
+          return x.as<std::ofstream>().is_open();
+        }
+        else
+        {
+          return x.is_also<std::ostream>();
+        }
+      });
 
-    define<procedure>("open-input-file",  [](let const& xs) { return make< input_file_port>(car(xs).as<string>()); });
-    define<procedure>("open-output-file", [](let const& xs) { return make<output_file_port>(car(xs).as<string>()); });
+      library.define<procedure>("standard-input-port", [](auto&&...)
+      {
+        return standard_input;
+      });
 
-    define<procedure>("close-input-port", [](let const& xs)
-    {
-      if (let const& x = car(xs); x.is_also<std::ifstream>())
+      library.define<procedure>("standard-output-port", [](auto&&...)
       {
-        x.as<std::ifstream>().close();
-      }
+        return standard_output;
+      });
 
-      return unspecified;
-    });
+      library.define<procedure>("standard-error-port", [](auto&&...)
+      {
+        return standard_error;
+      });
 
-    define<procedure>("close-output-port", [](let const& xs)
-    {
-      if (let const& x = car(xs); x.is_also<std::ofstream>())
+      library.define<procedure>("open-input-file", [](let const& xs)
       {
-        x.as<std::ofstream>().close();
-      }
+        return make<input_file_port>(car(xs).as<string>());
+      });
 
-      return unspecified;
-    });
+      library.define<procedure>("open-output-file", [](let const& xs)
+      {
+        return make<output_file_port>(car(xs).as<string>());
+      });
 
-    define<procedure>("open-input-string", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("close-input-port", [](let const& xs)
       {
-      case 0:
-        return make<input_string_port>();
+        if (let const& x = car(xs); x.is_also<std::ifstream>())
+        {
+          x.as<std::ifstream>().close();
+        }
 
-      case 1:
-        return make<input_string_port>(car(xs).as<string>());
+        return unspecified;
+      });
 
-      default:
-        throw invalid_application(intern("open-input-string") | xs);
-      }
-    });
+      library.define<procedure>("close-output-port", [](let const& xs)
+      {
+        if (let const& x = car(xs); x.is_also<std::ofstream>())
+        {
+          x.as<std::ofstream>().close();
+        }
 
-    define<procedure>("open-output-string", [](let const& xs)
-    {
-      switch (length(xs))
+        return unspecified;
+      });
+
+      library.define<procedure>("open-input-string", [](let const& xs)
       {
-      case 0:
-        return make<output_string_port>();
+        switch (length(xs))
+        {
+        case 0:
+          return make<input_string_port>();
 
-      case 1:
-        return make<output_string_port>(car(xs).as<string>());
+        case 1:
+          return make<input_string_port>(car(xs).as<string>());
 
-      default:
-        throw invalid_application(intern("open-output-string") | xs);
-      }
-    });
+        default:
+          throw invalid_application(intern("open-input-string") | xs);
+        }
+      });
 
-    define<procedure>("get-output-string", [](let const& xs)
-    {
-      return make<string>(car(xs).as<std::ostringstream>().str());
-    });
+      library.define<procedure>("open-output-string", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 0:
+          return make<output_string_port>();
 
-    define<procedure>("%read-char", [](let const& xs) -> value_type
-    {
-      try
+        case 1:
+          return make<output_string_port>(car(xs).as<string>());
+
+        default:
+          throw invalid_application(intern("open-output-string") | xs);
+        }
+      });
+
+      library.define<procedure>("get-output-string", [](let const& xs)
       {
-        return make<character>(car(xs).as<std::istream>());
-      }
-      catch (eof const&)
+        return make<string>(car(xs).as<std::ostringstream>().str());
+      });
+
+      library.define<procedure>("%read-char", [](let const& xs) -> value_type
       {
-        return eof_object;
-      }
-      catch (read_error const& error)
+        try
+        {
+          return make<character>(car(xs).as<std::istream>());
+        }
+        catch (eof const&)
+        {
+          return eof_object;
+        }
+        catch (read_error const& error)
+        {
+          return make(error);
+        }
+      });
+
+      library.define<procedure>("%peek-char", [](let const& xs) -> value_type
       {
-        return make(error);
-      }
-    });
+        try
+        {
+          auto const g = car(xs).as<std::istream>().tellg();
+          let const c = make<character>(car(xs).as<std::istream>());
+          car(xs).as<std::istream>().seekg(g);
+          return c;
+        }
+        catch (eof const&)
+        {
+          return eof_object;
+        }
+        catch (read_error const& error)
+        {
+          return make(error);
+        }
+      });
 
-    define<procedure>("%peek-char", [](let const& xs) -> value_type
-    {
-      try
+      library.define<predicate>("eof-object?", [](let const& xs)
       {
-        auto const g = car(xs).as<std::istream>().tellg();
-        let const c = make<character>(car(xs).as<std::istream>());
-        car(xs).as<std::istream>().seekg(g);
-        return c;
-      }
-      catch (eof const&)
+        return car(xs).is<eof>();
+      });
+
+      library.define<procedure>("eof-object", [](auto&&...)
       {
         return eof_object;
-      }
-      catch (read_error const& error)
+      });
+
+      library.define<predicate>("read-ready?", [](let const& xs)
       {
-        return make(error);
-      }
-    });
+        return static_cast<bool>(car(xs).as<std::istream>());
+      });
 
-    define<predicate>("eof-object?", [](let const& xs)
-    {
-      return car(xs).is<eof>();
-    });
+      library.define<procedure>("%read-string", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 2:
+          return make<string>(cadr(xs).as<std::istream>(), static_cast<string::size_type>(car(xs).as<exact_integer>()));
 
-    define<procedure>("eof-object", [](auto&&...)
-    {
-      return eof_object;
-    });
+        default:
+          throw invalid_application(intern("read-string") | xs);
+        }
+      });
 
-    define<predicate>("read-ready?", [](let const& xs)
-    {
-      return static_cast<bool>(car(xs).as<std::istream>());
-    });
+      library.define<procedure>("put-char", [](let const& xs)
+      {
+        cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<character>());
+        return unspecified;
+      });
 
-    define<procedure>("%read-string", [](let const& xs)
-    {
-      switch (length(xs))
+      library.define<procedure>("put-string", [](let const& xs)
       {
-      case 2:
-        return make<string>(cadr(xs).as<std::istream>(), static_cast<string::size_type>(car(xs).as<exact_integer>()));
+        switch (length(xs))
+        {
+        case 2:
+          cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<string>());
+          break;
 
-      default:
-        throw invalid_application(intern("read-string") | xs);
-      }
-    });
+        case 3: // TODO
+        case 4: // TODO
 
-    define<procedure>("put-char", [](let const& xs)
-    {
-      cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<character>());
-      return unspecified;
-    });
+        default:
+          throw invalid_application(intern("write-string") | xs);
+        }
 
-    define<procedure>("put-string", [](let const& xs)
-    {
-      switch (length(xs))
-      {
-      case 2:
-        cadr(xs).as<std::ostream>() << static_cast<external_representation>(car(xs).as<string>());
-        break;
+        return unspecified;
+      });
 
-      case 3: // TODO
-      case 4: // TODO
+      library.define<procedure>("%flush-output-port", [](let const& xs)
+      {
+        car(xs).as<std::ostream>() << std::flush;
+        return unspecified;
+      });
 
-      default:
-        throw invalid_application(intern("write-string") | xs);
-      }
+      library.export_("input-port?");
+      library.export_("output-port?");
+      library.export_("binary-port?");
+      library.export_("textual-port?");
+      library.export_("port?");
+      library.export_("input-port-open?");
+      library.export_("output-port-open?");
+      library.export_("standard-input-port");
+      library.export_("standard-output-port");
+      library.export_("standard-error-port");
+      library.export_("open-input-file");
+      library.export_("open-output-file");
+      library.export_("close-input-port");
+      library.export_("close-output-port");
+      library.export_("open-input-string");
+      library.export_("open-output-string");
+      library.export_("get-output-string");
+      library.export_("%read-char");
+      library.export_("%peek-char");
+      library.export_("eof-object?");
+      library.export_("eof-object");
+      library.export_("read-ready?");
+      library.export_("%read-string");
+      library.export_("put-char");
+      library.export_("put-string");
+      library.export_("%flush-output-port");
+    });
+
+    define_library("(meevax read)", [](library & library)
+    {
+      library.define<procedure>("%read", [=](let const& xs) mutable -> value_type
+      {
+        try
+        {
+          return library.read(car(xs));
+        }
+        catch (eof const&)
+        {
+          return eof_object;
+        }
+        catch (read_error const& error)
+        {
+          return make(error);
+        }
+      });
 
-      return unspecified;
+      library.export_("%read");
     });
 
-    define<procedure>("%flush-output-port", [](let const& xs)
+    define_library("(meevax string)", [](library & library)
     {
-      car(xs).as<std::ostream>() << std::flush;
-      return unspecified;
-    });
+      library.define<predicate>("string?", [](let const& xs)
+      {
+        return car(xs).is<string>();
+      });
 
-    export_("input-port?");
-    export_("output-port?");
-    export_("binary-port?");
-    export_("textual-port?");
-    export_("port?");
-    export_("input-port-open?");
-    export_("output-port-open?");
-    export_("standard-input-port");
-    export_("standard-output-port");
-    export_("standard-error-port");
-    export_("open-input-file");
-    export_("open-output-file");
-    export_("close-input-port");
-    export_("close-output-port");
-    export_("open-input-string");
-    export_("open-output-string");
-    export_("get-output-string");
-    export_("%read-char");
-    export_("%peek-char");
-    export_("eof-object?");
-    export_("eof-object");
-    export_("read-ready?");
-    export_("%read-string");
-    export_("put-char");
-    export_("put-string");
-    export_("%flush-output-port");
-  }
+      library.define<procedure>("make-string", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 1:
+          return make<string>(static_cast<string::size_type>(car(xs).as<exact_integer>()), character());
 
-  library::library(evaluate_library_t)
-  {
-    define<procedure>("eval", [](let const& xs)
-    {
-      return cadr(xs).as<environment>().evaluate(car(xs));
-    });
+        case 2:
+          return make<string>(static_cast<string::size_type>(car(xs).as<exact_integer>()), cadr(xs).as<character>());
 
-    export_("eval");
-  }
+        default:
+          throw invalid_application(intern("make-string") | xs);
+        }
+      });
 
-  library::library(read_library_t)
-  {
-    define<procedure>("%read", [this](let const& xs) -> value_type
-    {
-      try
-      {
-        return read(car(xs));
-      }
-      catch (eof const&)
+      library.define<procedure>("string-length", [](let const& xs)
       {
-        return eof_object;
-      }
-      catch (read_error const& error)
-      {
-        return make(error);
-      }
-    });
+        return make<exact_integer>(car(xs).as<string>().size());
+      });
 
-    export_("%read");
-  }
+      library.define<procedure>("string-ref", [](let const& xs)
+      {
+        return make(car(xs).as<string>().at(static_cast<string::size_type>(cadr(xs).as<exact_integer>())));
+      });
 
-  library::library(write_library_t)
-  {
-    define<procedure>("%write-simple", [](let const& xs)
-    {
-      kernel::write(cadr(xs), car(xs));
-      return unspecified;
-    });
+      library.define<procedure>("string-set!", [](let const& xs)
+      {
+        car(xs).as<string>().at(static_cast<string::size_type>(cadr(xs).as<exact_integer>())) = caddr(xs).as<character>();
+        return car(xs);
+      });
 
-    define<procedure>("print", [](let const& xs)
-    {
-      for (let const& x : xs)
+      library.define<procedure>("string-append", [](let const& xs)
       {
-        if (x.is<string>())
+        string result;
+
+        for (let const& x : xs)
         {
-          std::cout << static_cast<external_representation>(x.as<string>());
+          std::copy(std::cbegin(x.as<string>()), std::cend(x.as<string>()), std::back_inserter(result));
         }
-        else
+
+        return make(result);
+      });
+
+      library.define<procedure>("string-copy", [](let const& xs)
+      {
+        switch (length(xs))
         {
-          std::cout << x;
+        case 1:
+          return make<string>(car(xs).as<string>());
+
+        case 2:
+          return make<string>(car(xs).as<string>().begin() + static_cast<string::size_type>(cadr(xs).as<exact_integer>()),
+                              car(xs).as<string>().end());
+        case 3:
+          return make<string>(car(xs).as<string>().begin() + static_cast<string::size_type>( cadr(xs).as<exact_integer>()),
+                              car(xs).as<string>().begin() + static_cast<string::size_type>(caddr(xs).as<exact_integer>()));
+        default:
+          throw invalid_application(intern("string-copy") | xs);
         }
+      });
+
+      #define STRING_COMPARE(COMPARE)                                            \
+      [](let const& xs)                                                          \
+      {                                                                          \
+        return std::adjacent_find(                                               \
+                 std::begin(xs), std::end(xs), [](let const& a, let const& b)    \
+                 {                                                               \
+                   return not COMPARE(a.as_const<string>(),                      \
+                                      b.as_const<string>());                     \
+                 }) == std::end(xs);                                             \
       }
 
-      std::cout << std::endl;
+      library.define<predicate>("string=?",  STRING_COMPARE(std::equal_to     <void>()));
+      library.define<predicate>("string<?",  STRING_COMPARE(std::less         <void>()));
+      library.define<predicate>("string<=?", STRING_COMPARE(std::less_equal   <void>()));
+      library.define<predicate>("string>?",  STRING_COMPARE(std::greater      <void>()));
+      library.define<predicate>("string>=?", STRING_COMPARE(std::greater_equal<void>()));
 
-      return standard_output;
-    });
+      #undef STRING_COMPARE
 
-    export_("%write-simple");
-    export_("print");
-  }
-
-  library::library(macro_library_t)
-  {
-    define<predicate>("identifier?", [](let const& xs)
-    {
-      return car(xs).is_also<identifier>();
-    });
-
-    define<procedure>("identifier->symbol", [](let const& xs)
-    {
-      if (let const& x = car(xs); x.is<syntactic_closure>())
-      {
-        return x.as<syntactic_closure>().expression;
-      }
-      else
+      library.define<procedure>("string->number", [](let const& xs)
       {
-        return x;
-      }
-    });
+        switch (length(xs))
+        {
+        case 1:
+          return string_to::number(car(xs).as<string>(), 10);
 
-    define<predicate>("transformer?", [](let const& xs)
-    {
-      return car(xs).is_also<transformer>();
-    });
+        case 2:
+          return string_to::number(car(xs).as<string>(), static_cast<int>(cadr(xs).as<exact_integer>()));
 
-    define<predicate>("syntactic-closure?", [](let const& xs)
-    {
-      return car(xs).is<syntactic_closure>();
-    });
+        default:
+          throw invalid_application(intern("string->number") | xs);
+        }
+      });
 
-    define<procedure>("make-syntactic-closure", [](let const& xs)
-    {
-      return make<syntactic_closure>(car(xs), cadr(xs), caddr(xs));
-    });
+      library.define<procedure>("string->list", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 1:
+          return car(xs).as<string>().list();
 
-    export_("identifier?");
-    export_("identifier->symbol");
-    export_("transformer?");
-    export_("syntactic-closure?");
-    export_("make-syntactic-closure");
-  }
+        case 2:
+          return car(xs).as<string>().list(static_cast<string::size_type>(cadr(xs).as<exact_integer>()));
 
-  library::library(experimental_library_t)
-  {
-    define<procedure>("type-of", [](let const& xs)
-    {
-      std::cout << car(xs).type().name() << std::endl;
+        case 3:
+          return car(xs).as<string>().list(static_cast<string::size_type>(cadr(xs).as<exact_integer>()), static_cast<string::size_type>(caddr(xs).as<exact_integer>()));
 
-      return standard_output;
-    });
+        default:
+          throw invalid_application(intern("string->list") | xs);
+        }
+      });
 
-    define<procedure>("disassemble", [](let const& xs)
-    {
-      if (0 < length(xs))
+      library.define<procedure>("string->symbol", [](let const& xs)
       {
-        if (let const& f = car(xs); f.is<closure>())
-        {
-          disassemble(std::cout, car(f));
-        }
-      }
+        return intern(car(xs).as<string>());
+      });
 
-      return standard_output;
-    });
+      library.export_("string?");
+      library.export_("make-string");
+      library.export_("string-append");
+      library.export_("string-copy");
+      library.export_("string-length");
+      library.export_("string-ref");
+      library.export_("string-set!");
+      library.export_("string=?");
+      library.export_("string<?");
+      library.export_("string<=?");
+      library.export_("string>?");
+      library.export_("string>=?");
+      library.export_("string->list");
+      library.export_("string->number");
+      library.export_("string->symbol");
+    });
+
+    define_library("(meevax symbol)", [](library & library)
+    {
+      library.define<predicate>("symbol?", [](let const& xs)
+      {
+        return car(xs).is<symbol>();
+      });
 
-    define<predicate>("ieee-float?", [](auto&&...)
-    {
-      return std::numeric_limits<double>::is_iec559;
-    });
+      library.define<procedure>("symbol->string", [](let const& xs)
+      {
+        return make<string>(car(xs).as<symbol>());
+      });
 
-    export_("type-of");
-    export_("disassemble");
-    export_("ieee-float?");
-  }
+      library.export_("symbol?");
+      library.export_("symbol->string");
+    });
+
+    define_library("(meevax syntax)", [](library & library)
+    {
+      library.define<syntax>("begin", machine::begin);
+      library.define<syntax>("call-with-current-continuation!", call_with_current_continuation);
+      library.define<syntax>("define", machine::define);
+      library.define<syntax>("define-syntax", define_syntax);
+      library.define<syntax>("if", if_);
+      library.define<syntax>("lambda", lambda);
+      library.define<syntax>("let-syntax", let_syntax);
+      library.define<syntax>("letrec", letrec);
+      library.define<syntax>("letrec-syntax", letrec_syntax);
+      library.define<syntax>("quote", quote);
+      library.define<syntax>("quote-syntax", quote_syntax);
+      library.define<syntax>("set!", set);
+
+      library.export_("begin");
+      library.export_("call-with-current-continuation!");
+      library.export_("define");
+      library.export_("define-syntax");
+      library.export_("if");
+      library.export_("lambda");
+      library.export_("let-syntax");
+      library.export_("letrec");
+      library.export_("letrec-syntax");
+      library.export_("quote");
+      library.export_("quote-syntax");
+      library.export_("set!");
+    });
+
+    define_library("(meevax vector)", [](library & library)
+    {
+      library.define<predicate>("vector?", [](let const& xs)
+      {
+        return car(xs).is<vector>();
+      });
 
-  library::library(context_library_t)
-  {
-    define<procedure>("emergency-exit", [](let const& xs) -> value_type
-    {
-      switch (length(xs))
+      library.define<procedure>("vector", [](let const& xs)
       {
-      case 0:
-        throw exit_status::success;
+        return make<vector>(xs);
+      });
 
-      case 1:
-        if (let const& x = car(xs); x.is<bool>())
-        {
-          throw select(x) ? exit_status::success : exit_status::failure;
-        }
-        else if (x.is<exact_integer>())
+      library.define<procedure>("make-vector", [](let const& xs)
+      {
+        switch (length(xs))
         {
-          throw exit_status(static_cast<int>(x.as<exact_integer>()));
-        }
-        else [[fallthrough]];
+        case 1:
+          return make<vector>(car(xs), unspecified);
 
-      default:
-        throw invalid_application(intern("emergency-exit") | xs);
-      }
-    });
+        case 2:
+          return make<vector>(car(xs), cadr(xs));
 
-    export_("emergency-exit");
-  }
-
-  library::library(const_reference declarations)
-    : declarations { declarations }
-  {}
+        default:
+          throw invalid_application(intern("make-vector") | xs);
+        }
+      });
 
-  auto library::boot() -> void
-  {
-    define_library("(meevax character)", character_library);
-    define_library("(meevax context)", context_library);
-    define_library("(meevax control)", control_library);
-    define_library("(meevax environment)", environment_library);
-    define_library("(meevax equivalence)", equivalence_library);
-    define_library("(meevax evaluate)", evaluate_library);
-    define_library("(meevax exception)", exception_library);
-    define_library("(meevax experimental)", experimental_library);
-    define_library("(meevax inexact)", inexact_library);
-    define_library("(meevax list)", list_library);
-    define_library("(meevax macro)", macro_library);
-    define_library("(meevax number)", number_library);
-    define_library("(meevax pair)", pair_library);
-    define_library("(meevax port)", port_library);
-    define_library("(meevax read)", read_library);
-    define_library("(meevax string)", string_library);
-    define_library("(meevax symbol)", symbol_library);
-    define_library("(meevax syntax)", syntax_library);
-    define_library("(meevax vector)", vector_library);
-    define_library("(meevax write)", write_library);
+      library.define<procedure>("vector-length", [](let const& xs)
+      {
+        return car(xs).as<vector>().length();
+      });
 
-    define_library("(meevax foreign-function)", [](library & library)
-    {
-      library.define<procedure>("foreign-function", [](let const& xs)
+      library.define<procedure>("vector-ref", [](let const& xs)
       {
-        return make<procedure>(cadr(xs).as<string>(), car(xs).as<string>());
+        return car(xs).as<vector>().ref(cadr(xs));
       });
 
-      library.define<predicate>("foreign-function?", [](let const& xs)
+      library.define<procedure>("vector-set!", [](let const& xs)
       {
-        return car(xs).is<procedure>();
+        return car(xs).as<vector>().set(cadr(xs), caddr(xs));
       });
 
-      library.export_("foreign-function");
-      library.export_("foreign-function?");
-    });
+      library.define<procedure>("vector-fill!", [](let const& xs)
+      {
+        switch (length(xs))
+        {
+        case 2:
+          car(xs).as<vector>().fill(cadr(xs), e0, car(xs).as<vector>().length());
+          break;
 
-    define_library("(meevax garbage-collector)", [](library & library)
-    {
-      library.define<procedure>("gc-collect", [](auto&&...)
+        case 3:
+          car(xs).as<vector>().fill(cadr(xs), caddr(xs), car(xs).as<vector>().length());
+          break;
+
+        case 4:
+          car(xs).as<vector>().fill(cadr(xs), caddr(xs), cadddr(xs));
+          break;
+
+        default:
+          throw invalid_application(intern("vector-fill!") | xs);
+        }
+
+        return unspecified;
+      });
+
+      library.define<procedure>("vector->list", [](let const& xs)
       {
-        return make<exact_integer>(gc.collect());
+        switch (length(xs))
+        {
+        case 1:
+          return car(xs).as<vector>().list(e0, car(xs).as<vector>().length());
+
+        case 2:
+          return car(xs).as<vector>().list(cadr(xs), car(xs).as<vector>().length());
+
+        case 3:
+          return car(xs).as<vector>().list(cadr(xs), caddr(xs));
+
+        default:
+          throw invalid_application(intern("vector->list") | xs);
+        }
       });
 
-      library.define<procedure>("gc-count", [](auto&&...)
+      library.define<procedure>("vector->string", [](let const& xs)
       {
-        return make<exact_integer>(gc.count());
+        switch (length(xs))
+        {
+        case 1:
+          return car(xs).as<vector>().string(e0, car(xs).as<vector>().length());
+
+        case 2:
+          return car(xs).as<vector>().string(cadr(xs), car(xs).as<vector>().length());
+
+        case 3:
+          return car(xs).as<vector>().string(cadr(xs), caddr(xs));
+
+        default:
+          throw invalid_application(intern("vector->string") | xs);
+        }
       });
 
-      library.export_("gc-collect");
-      library.export_("gc-count");
+      library.export_("vector?");
+      library.export_("vector");
+      library.export_("make-vector");
+      library.export_("vector-length");
+      library.export_("vector-ref");
+      library.export_("vector-set!");
+      library.export_("vector-fill!");
+      library.export_("vector->list");
+      library.export_("vector->string");
     });
 
     define_library("(meevax version)", [](library & library)
@@ -1213,6 +1325,37 @@ inline namespace kernel
       library.export_("features");
     });
 
+    define_library("(meevax write)", [](library & library)
+    {
+      library.define<procedure>("%write-simple", [](let const& xs)
+      {
+        kernel::write(cadr(xs), car(xs));
+        return unspecified;
+      });
+
+      library.define<procedure>("print", [](let const& xs)
+      {
+        for (let const& x : xs)
+        {
+          if (x.is<string>())
+          {
+            std::cout << static_cast<external_representation>(x.as<string>());
+          }
+          else
+          {
+            std::cout << x;
+          }
+        }
+
+        std::cout << std::endl;
+
+        return standard_output;
+      });
+
+      library.export_("%write-simple");
+      library.export_("print");
+    });
+
     std::vector<string_view> const codes {
       srfi_211,
       r4rs_essential,

From 4ac8dcba2064b939541e5769fbabeab44d1ea0f4 Mon Sep 17 00:00:00 2001
From: yamacir-kit <httperror@404-notfound.jp>
Date: Sun, 10 Jul 2022 00:56:58 +0900
Subject: [PATCH 36/36] Update procedure `%read` to use
 `interaction-environment`

Signed-off-by: yamacir-kit <httperror@404-notfound.jp>
---
 README.md              | 6 +++---
 VERSION                | 2 +-
 src/kernel/library.cpp | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index c22882958..3028a4479 100644
--- a/README.md
+++ b/README.md
@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.116.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.117.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.116_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.117_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.116
+Meevax Lisp System, version 0.4.117
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 6a8693646..1356ff810 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.116
+0.4.117
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index 17d695a8e..310bb404f 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -997,11 +997,11 @@ inline namespace kernel
 
     define_library("(meevax read)", [](library & library)
     {
-      library.define<procedure>("%read", [=](let const& xs) mutable -> value_type
+      library.define<procedure>("%read", [](let const& xs) mutable -> value_type
       {
         try
         {
-          return library.read(car(xs));
+          return interaction_environment().as<environment>().read(car(xs));
         }
         catch (eof const&)
         {