Rename basic_function_result -> function_result

Author: cschreib

README.md

@@ -227,12 +227,12 @@ Supported types for the C++ function parameters:
  - `jsonexpr::null_t = std::nullptr_t`, for null.
  - `jsonexpr::json = nlohmann::json`, for "any of the above" (handle type checks yourself).
 
-The return value must be (convertible to) `jsonexpr::json`, or `jsonexpr::basic_function_result` if handling errors (see below for more information on error handling).
+The return value must be (convertible to) `jsonexpr::json`, or `jsonexpr::function_result` if handling errors (see below for more information on error handling).
 
 
 #### Error handling
 
-The library will automatically take care of validating the type of each argument passed to this function, and report appropriate errors in case of a mismatch. However, if the function has error states based on the *values* of the parameters (e.g., here: the length of the array, or the types of the elements within it), these errors need to be handled and reported explicitly. This is done by returning a `jsonexpr::basic_function_result`, which is an alias for `jsonexpr::expected<jsonexpr::json, std::string>` (either a JSON value, or an error message).
+The library will automatically take care of validating the type of each argument passed to this function, and report appropriate errors in case of a mismatch. However, if the function has error states based on the *values* of the parameters (e.g., here: the length of the array, or the types of the elements within it), these errors need to be handled and reported explicitly. This is done by returning a `jsonexpr::function_result`, which is an alias for `jsonexpr::expected<jsonexpr::json, std::string>` (either a JSON value, or an error message).
 
 In the example below, we check that each element in the array is a string:
 
@@ -244,7 +244,7 @@ int main() {
     jsonexpr::register_function(
         funcs, "join",
         [](const std::vector<jsonexpr::json>& array,
-           const std::string&                 separator) -> jsonexpr::basic_function_result {
+           const std::string&                 separator) -> jsonexpr::function_result {
             for (std::size_t i = 0; i < array.size(); ++i) {
                 if (!array[i].is_string()) {
                     return jsonexpr::unexpected(

libjsonexpr/include/jsonexpr/base.hpp

@@ -70,21 +70,21 @@ std::string_view get_type_name(const T&) noexcept {
     return get_type_name<T>();
 }
 
-using function_result       = expected<json, error>;
-using basic_function_result = expected<json, std::string>;
+using ast_function_result = expected<json, error>;
+using function_result     = expected<json, std::string>;
 
 template<typename... Args>
-using basic_function_ptr = basic_function_result (*)(const Args&...);
+using basic_function_ptr = function_result (*)(const Args&...);
 
 struct function;
 using function_registry = std::unordered_map<std::string, function>;
 
 using variable_registry = std::unordered_map<std::string, json>;
 
 struct function {
-    using ast_function_t   = std::function<function_result(
+    using ast_function_t   = std::function<ast_function_result(
         std::span<const ast::node>, const variable_registry&, const function_registry&)>;
-    using basic_function_t = std::function<basic_function_result(std::span<const json>)>;
+    using basic_function_t = std::function<function_result(std::span<const json>)>;
 
     using overload_t = std::unordered_map<std::string, basic_function_t>;
 

libjsonexpr/include/jsonexpr/functions.hpp

@@ -25,7 +25,7 @@ template<typename... Args>
 struct type_list {};
 
 template<typename Function, typename... Args, std::size_t... Indices>
-basic_function_result call(
+function_result call(
     Function              func,
     std::span<const json> args,
     type_list<Args...>,
@@ -45,17 +45,15 @@ concept stateless_lambda = (!function_ptr<T>) && requires(const T& func) {
 } // namespace impl
 
 template<typename R, typename... Args>
-    requires std::is_convertible_v<R, basic_function_result>
+    requires std::is_convertible_v<R, function_result>
 void register_function(function_registry& funcs, std::string_view name, R (*func)(Args...)) {
     std::string key;
     (impl::add_type(key, get_type_name<std::decay_t<Args>>()), ...);
 
-    funcs[std::string{name}].add_overload(
-        key, [=](std::span<const json> args) -> basic_function_result {
-            return impl::call(
-                func, args, impl::type_list<Args...>{},
-                std::make_index_sequence<sizeof...(Args)>{});
-        });
+    funcs[std::string{name}].add_overload(key, [=](std::span<const json> args) -> function_result {
+        return impl::call(
+            func, args, impl::type_list<Args...>{}, std::make_index_sequence<sizeof...(Args)>{});
+    });
 }
 
 template<impl::stateless_lambda Func>
@@ -66,7 +64,7 @@ void register_function(function_registry& funcs, std::string_view name, const Fu
 JSONEXPR_EXPORT void register_ast_function(
     function_registry&                                                                   funcs,
     std::string_view                                                                     name,
-    std::function<function_result(
+    std::function<ast_function_result(
         std::span<const ast::node>, const variable_registry&, const function_registry&)> func);
 
 JSONEXPR_EXPORT function_registry default_functions();

libjsonexpr/src/eval.cpp

@@ -68,7 +68,7 @@ expected<json, error> eval(
     try {
         const auto args = std::span<const ast::node>(f.args.begin(), f.args.end());
 
-        auto result = [&]() -> function_result {
+        auto result = [&]() -> ast_function_result {
             if (std::holds_alternative<function::ast_function_t>(func.overloads)) {
                 return std::get<function::ast_function_t>(func.overloads)(args, vreg, freg);
             } else {