Merge pull request #468 from yamacir-kit/release-candidate

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.63_amd64.deb
+sudo apt install build/meevax_0.5.66_amd64.deb
 ```
 
 or
@@ -123,9 +123,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name | Description
 |-------------|-------------
-| `all`       | Build shared-library `libmeevax.0.5.63.so` and executable `meevax`
+| `all`       | Build shared-library `libmeevax.0.5.66.so` and executable `meevax`
 | `test`      | Test executable `meevax`
-| `package`   | Generate debian package `meevax_0.5.63_amd64.deb`
+| `package`   | Generate debian package `meevax_0.5.66_amd64.deb`
 | `install`   | Copy files into `/usr/local` directly
 
 ## Usage

VERSION

@@ -1 +1 @@
-0.5.63
+0.5.66

]end(

@@ -124,7 +124,7 @@ inline namespace kernel
         }),
       };
 
-      auto search = [&](auto&& name) -> auto const&
+      auto search = [&](auto&& name) -> decltype(auto)
       {
         if (auto iter = std::find_if(options.begin(), options.end(), [&](auto&& option)
                         {

include/meevax/kernel/configurator.hpp

@@ -75,7 +75,7 @@ inline namespace kernel
       std::copy(begin, end, std::begin(valarray));
     }
 
-    static auto tag() -> auto const&
+    static auto tag() -> decltype(auto)
     {
       auto static const tag = lexical_cast<std::string>(std::is_integral_v<T> ? std::is_signed_v<T> ? 's' : 'u' : 'f', sizeof(T) * CHAR_BIT);
       return tag;

include/meevax/kernel/homogeneous_vector.hpp

@@ -17,8 +17,7 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_IMPLEMENTATION_DEPENDENT_HPP
 #define INCLUDED_MEEVAX_KERNEL_IMPLEMENTATION_DEPENDENT_HPP
 
-#include <meevax/kernel/error.hpp>
-#include <meevax/kernel/list.hpp>
+#include <meevax/kernel/pair.hpp>
 
 namespace meevax
 {

include/meevax/kernel/implementation_dependent.hpp

@@ -17,6 +17,7 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_INSTRUCTION_HPP
 #define INCLUDED_MEEVAX_KERNEL_INSTRUCTION_HPP
 
+#include <cstdint>
 #include <iostream>
 
 namespace meevax

include/meevax/kernel/instruction.hpp

@@ -24,87 +24,11 @@ namespace meevax
 {
 inline namespace kernel
 {
-  template <auto N, typename T>
-  auto get(T&& x) -> decltype(auto)
-  {
-    if constexpr (std::is_same_v<std::decay_t<T>, pair::iterator>)
-    {
-      return std::get<N>(*x.current);
-    }
-    else if constexpr (std::is_same_v<std::decay_t<T>, object>)
-    {
-      return std::get<N>(x.template as<pair>());
-    }
-    else
-    {
-      return std::get<N>(x);
-    }
-  }
-
-  inline auto car = [](auto&& x) -> decltype(auto)
-  {
-    return get<0>(std::forward<decltype(x)>(x));
-  };
-
-  inline auto cdr = [](auto&& x) -> decltype(auto)
-  {
-    return get<1>(std::forward<decltype(x)>(x));
-  };
-
-  inline constexpr auto caar = compose(car, car);
-  inline constexpr auto cadr = compose(car, cdr);
-  inline constexpr auto cdar = compose(cdr, car);
-  inline constexpr auto cddr = compose(cdr, cdr);
-
-  inline constexpr auto caaar = compose(car, caar);
-  inline constexpr auto caadr = compose(car, cadr);
-  inline constexpr auto cadar = compose(car, cdar);
-  inline constexpr auto caddr = compose(car, cddr);
-  inline constexpr auto cdaar = compose(cdr, caar);
-  inline constexpr auto cdadr = compose(cdr, cadr);
-  inline constexpr auto cddar = compose(cdr, cdar);
-  inline constexpr auto cdddr = compose(cdr, cddr);
-
-  inline constexpr auto caaaar = compose(car, caaar);
-  inline constexpr auto caaadr = compose(car, caadr);
-  inline constexpr auto caadar = compose(car, cadar);
-  inline constexpr auto caaddr = compose(car, caddr);
-  inline constexpr auto cadaar = compose(car, cdaar);
-  inline constexpr auto cadadr = compose(car, cdadr);
-  inline constexpr auto caddar = compose(car, cddar);
-  inline constexpr auto cadddr = compose(car, cdddr);
-  inline constexpr auto cdaaar = compose(cdr, caaar);
-  inline constexpr auto cdaadr = compose(cdr, caadr);
-  inline constexpr auto cdadar = compose(cdr, cadar);
-  inline constexpr auto cdaddr = compose(cdr, caddr);
-  inline constexpr auto cddaar = compose(cdr, cdaar);
-  inline constexpr auto cddadr = compose(cdr, cdadr);
-  inline constexpr auto cdddar = compose(cdr, cddar);
-  inline constexpr auto cddddr = compose(cdr, cdddr);
-
-  template <typename T, typename U, REQUIRES(std::is_convertible<T, object>,
-                                             std::is_convertible<U, object>)>
-  auto operator |(T&& x, U&& y) -> decltype(auto)
-  {
-    return make<pair>(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
-  }
-
-  inline auto cons = [](auto&&... xs) constexpr
-  {
-    return (std::forward<decltype(xs)>(xs) | ...);
-  };
-
   inline auto list = [](auto&&... xs) constexpr
   {
     return (std::forward<decltype(xs)>(xs) | ... | unit);
   };
 
-  inline auto xcons = [](auto&& x, auto&& y) constexpr
-  {
-    return cons(std::forward<decltype(y)>(y),
-                std::forward<decltype(x)>(x));
-  };
-
   auto make_list(std::size_t, object const& = unit) -> object;
 
   auto iota(std::size_t, object const& = e0, object const& = e1) -> object;

include/meevax/kernel/list.hpp

@@ -175,6 +175,82 @@ inline namespace kernel
   };
 
   auto operator <<(std::ostream &, pair const&) -> std::ostream &;
+
+  template <typename T, typename U, REQUIRES(std::is_constructible<pair, T, U>)>
+  auto operator |(T&& x, U&& y) -> decltype(auto)
+  {
+    return make<pair>(std::forward<decltype(x)>(x),
+                      std::forward<decltype(y)>(y));
+  }
+
+  inline auto cons = [](auto&&... xs) constexpr
+  {
+    return (std::forward<decltype(xs)>(xs) | ...);
+  };
+
+  inline auto xcons = [](auto&& x, auto&& y) constexpr
+  {
+    return cons(std::forward<decltype(y)>(y),
+                std::forward<decltype(x)>(x));
+  };
+
+  template <auto N, typename T>
+  auto get(T&& x) -> decltype(auto)
+  {
+    if constexpr (std::is_same_v<std::decay_t<T>, pair::iterator>)
+    {
+      return std::get<N>(*x.current);
+    }
+    else if constexpr (std::is_same_v<std::decay_t<T>, object>)
+    {
+      return std::get<N>(x.template as<pair>());
+    }
+    else
+    {
+      return std::get<N>(x);
+    }
+  }
+
+  inline auto car = [](auto&& x) -> decltype(auto)
+  {
+    return get<0>(std::forward<decltype(x)>(x));
+  };
+
+  inline auto cdr = [](auto&& x) -> decltype(auto)
+  {
+    return get<1>(std::forward<decltype(x)>(x));
+  };
+
+  inline constexpr auto caar = compose(car, car);
+  inline constexpr auto cadr = compose(car, cdr);
+  inline constexpr auto cdar = compose(cdr, car);
+  inline constexpr auto cddr = compose(cdr, cdr);
+
+  inline constexpr auto caaar = compose(car, caar);
+  inline constexpr auto caadr = compose(car, cadr);
+  inline constexpr auto cadar = compose(car, cdar);
+  inline constexpr auto caddr = compose(car, cddr);
+  inline constexpr auto cdaar = compose(cdr, caar);
+  inline constexpr auto cdadr = compose(cdr, cadr);
+  inline constexpr auto cddar = compose(cdr, cdar);
+  inline constexpr auto cdddr = compose(cdr, cddr);
+
+  inline constexpr auto caaaar = compose(car, caaar);
+  inline constexpr auto caaadr = compose(car, caadr);
+  inline constexpr auto caadar = compose(car, cadar);
+  inline constexpr auto caaddr = compose(car, caddr);
+  inline constexpr auto cadaar = compose(car, cdaar);
+  inline constexpr auto cadadr = compose(car, cdadr);
+  inline constexpr auto caddar = compose(car, cddar);
+  inline constexpr auto cadddr = compose(car, cdddr);
+  inline constexpr auto cdaaar = compose(cdr, caaar);
+  inline constexpr auto cdaadr = compose(cdr, caadr);
+  inline constexpr auto cdadar = compose(cdr, cadar);
+  inline constexpr auto cdaddr = compose(cdr, caddr);
+  inline constexpr auto cddaar = compose(cdr, cdaar);
+  inline constexpr auto cddadr = compose(cdr, cdadr);
+  inline constexpr auto cdddar = compose(cdr, cddar);
+  inline constexpr auto cddddr = compose(cdr, cdddr);
 } // namespace kernel
 } // namespace meevax