Rename struct callable to primitive_procedure

Signed-off-by: yamacir-kit <[email protected]>

Author: yamacir-kit

README.md

@@ -91,7 +91,7 @@ Procedures for each standard are provided by the following R7RS-style libraries:
 cmake -B build -DCMAKE_BUILD_TYPE=Release
 cd build
 make package
-sudo apt install build/meevax_0.5.106_amd64.deb
+sudo apt install build/meevax_0.5.107_amd64.deb
 ```
 
 or
@@ -123,9 +123,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name | Description
 |-------------|-------------
-| `all`       | Build shared-library `libmeevax.0.5.106.so` and executable `meevax`
+| `all`       | Build shared-library `libmeevax.0.5.107.so` and executable `meevax`
 | `test`      | Test executable `meevax`
-| `package`   | Generate debian package `meevax_0.5.106_amd64.deb`
+| `package`   | Generate debian package `meevax_0.5.107_amd64.deb`
 | `install`   | Copy files into `/usr/local` directly
 
 ## Usage

VERSION

@@ -1 +1 @@
-0.5.106
+0.5.107

include/meevax/kernel/dynamic_environment.hpp

@@ -286,16 +286,16 @@ inline namespace kernel
             s = unit;
             goto fetch;
           }
-          else if (callee.is_also<callable>()) /* ------------------------------
+          else if (callee.is_also<primitive_procedure>()) /* -------------------
           *
-          *  (<callable> xs . s) e (%call . c) d => (x . s) e c d
+          *  (<primitive-procedure> xs . s) e (%call . c) d => (x . s) e c d
           *
-          *  where x = procedure(xs)
+          *  where x = primitive-procedure(xs)
           *
           * ----------------------------------------------------------------- */
           {
             assert(tail(c, 1).template is<pair>());
-            s = cons(callee.as<callable>()(cadr(s)), cddr(s));
+            s = cons(callee.as<primitive_procedure>()(cadr(s)), cddr(s));
             c = cdr(c);
             goto fetch;
           }
@@ -336,17 +336,17 @@ inline namespace kernel
             s = unit;
             goto fetch;
           }
-          else if (callee.is_also<callable>()) /* ------------------------------
+          else if (callee.is_also<primitive_procedure>()) /* -------------------
           *
-          *  (<callable> xs) e (%tail-call) (s' e' c' . d) => (x . s') e' c' d
+          *  (<primitive-procedure> xs) e (%tail-call) (s' e' c' . d) => (x . s') e' c' d
           *
-          *  where x = procedure(xs)
+          *  where x = primitive-procedure(xs)
           *
           * ----------------------------------------------------------------- */
           {
             assert(tail(s, 2).template is<null>());
             assert(tail(c, 1).template is<null>());
-            s = cons(callee.as<callable>()(cadr(s)), car(d));
+            s = cons(callee.as<primitive_procedure>()(cadr(s)), car(d));
             e = cadr(d);
             c = caddr(d);
             d = cdddr(d);

include/meevax/kernel/procedure.hpp

@@ -25,26 +25,28 @@ namespace meevax
 {
 inline namespace kernel
 {
-  struct callable
+  struct primitive_procedure
   {
+    using signature = auto (*)(object &) -> object;
+
     std::string const name;
 
-    explicit callable(std::string const& name)
+    explicit primitive_procedure(std::string const& name)
       : name { name }
     {}
 
     virtual auto operator ()(object & = unit) const -> object = 0;
   };
 
-  auto operator <<(std::ostream &, callable const&) -> std::ostream &;
+  auto operator <<(std::ostream &, primitive_procedure const&) -> std::ostream &;
 
   template <typename F>
-  struct generic_procedure : public callable
+  struct generic_procedure : public primitive_procedure
   {
     std::enable_if_t<std::is_invocable_v<F> or std::is_invocable_v<F, object &>, F> invocable;
 
     explicit generic_procedure(std::string const& name, F f)
-      : callable { name }
+      : primitive_procedure { name }
       , invocable { f }
     {}
 
@@ -95,67 +97,68 @@ inline namespace kernel
      into function pointer types to reduce the number of template
      instantiations.
   */
-  template <typename, typename F, typename = void>
-  struct procedure
+  template <typename F, typename = void>
+  struct procedure_traits
   {
     using type = generic_procedure<F>;
   };
 
   /*
      Thunk
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)() -> object>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)() -> object>>>
   {
     using type = generic_procedure<auto (*)() -> object>;
   };
 
   /*
      Procedure
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> object>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> object>>>
   {
     using type = generic_procedure<auto (*)(object const&) -> object>;
   };
 
   /*
      Linear update procedure
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object &) -> object>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object &) -> object>>>
   {
     using type = generic_procedure<auto (*)(object &) -> object>;
   };
 
   /*
      Predicate
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> bool>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> bool>>>
   {
     using type = generic_procedure<auto (*)(object const&) -> bool>;
   };
 
   /*
      Command
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> void>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object const&) -> void>>>
   {
     using type = generic_procedure<auto (*)(object const&) -> void>;
   };
 
   /*
      Mutation
   */
-  template <typename T, typename F>
-  struct procedure<T, F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object &) -> void>>>
+  template <typename F>
+  struct procedure_traits<F, std::enable_if_t<std::is_convertible_v<F, auto (*)(object &) -> void>>>
   {
     using type = generic_procedure<auto (*)(object &) -> void>;
   };
 
-  using procedure_pointer = auto (*)(object &) -> object;
+  template <typename T, typename... Ts>
+  using procedure = std::enable_if_t<std::is_convertible_v<T, std::string>, procedure_traits<Ts...>>;
 } // namespace kernel
 } // namespace meevax
 

src/kernel/boot.cpp

@@ -1302,13 +1302,13 @@ inline namespace kernel
 
       library.define<procedure>("procedure?", [](let const& xs)
       {
-        return car(xs).is<closure>() or car(xs).is<continuation>() or car(xs).is_also<callable>();
+        return car(xs).is<closure>() or car(xs).is<continuation>() or car(xs).is_also<primitive_procedure>();
       });
 
       library.define<procedure>("procedure", [](let const& xs)
       {
         return make<procedure>(cadr(xs).as<symbol>(),
-                               reinterpret_cast<procedure_pointer>(
+                               reinterpret_cast<primitive_procedure::signature>(
                                  primary_collector().dlsym(cadr(xs).as<symbol>(),
                                                            primary_collector().dlopen(car(xs).as<string>()))));
       });

src/kernel/procedure.cpp

@@ -21,7 +21,7 @@ namespace meevax
 {
 inline namespace kernel
 {
-  auto operator <<(std::ostream & os, callable const& datum) -> std::ostream &
+  auto operator <<(std::ostream & os, primitive_procedure const& datum) -> std::ostream &
   {
     return os << magenta("#,(") << green("procedure") << " " << symbol(datum.name) << magenta(")");
   }