rice 3.0.0 → 4.0.3

data/rice/detail/NativeAttribute.ipp

@@ -0,0 +1,83 @@
+#include <array>
+#include <algorithm>
+
+#include "rice_traits.hpp"
+#include "method_data.hpp"
+#include "to_ruby_defn.hpp"
+#include "../ruby_try_catch.hpp"
+
+namespace Rice::detail
+{
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::get(VALUE self)
+  {
+    RUBY_TRY
+    {
+      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
+      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
+      return attr->read(self);
+    }
+    RUBY_CATCH
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::set(VALUE self, VALUE value)
+  {
+    RUBY_TRY
+    {
+      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
+      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
+      return attr->write(self, value);
+    }
+    RUBY_CATCH
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  NativeAttribute<Return_T, Attr_T, Self_T>::NativeAttribute(Attr_T attr, AttrAccess access)
+    : attr_(attr), access_(access)
+  {
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::read(VALUE self)
+  {
+    using Unqualified_T = remove_cv_recursive_t<Return_T>;
+    if constexpr (std::is_member_object_pointer_v<Attr_T>)
+    {
+      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
+      return To_Ruby<Unqualified_T>().convert(nativeSelf->*attr_);
+    }
+    else
+    {
+      return To_Ruby<Unqualified_T>().convert(*attr_);
+    }
+  }
+
+  template<typename Return_T, typename Attr_T, typename Self_T>
+  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::write(VALUE self, VALUE value)
+  {
+    if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>> && std::is_member_object_pointer_v<Attr_T>)
+    {
+      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
+      nativeSelf->*attr_ = From_Ruby<Return_T>().convert(value);
+    }
+    else if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>>)
+    {
+      *attr_ = From_Ruby<Return_T>().convert(value);
+    }
+    return value;
+  }
+
+  template<typename T>
+  auto* Make_Native_Attribute(T* attr, AttrAccess access)
+  {
+    return new NativeAttribute<T, T*>(attr, access);
+  }
+
+  template<typename Class_T, typename T>
+  auto* Make_Native_Attribute(T Class_T::* attr, AttrAccess access)
+  {
+    using Attr_T = T Class_T::*;
+    return new NativeAttribute<T, Attr_T, Class_T>(attr, access);
+  }
+} // Rice

data/rice/detail/NativeFunction.hpp

@@ -0,0 +1,69 @@
+#ifndef Rice__detail__Native_Function__hpp_
+#define Rice__detail__Native_Function__hpp_
+
+#include "ruby.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "MethodInfo.hpp"
+#include "function_traits.hpp"
+#include "from_ruby.hpp"
+
+namespace Rice::detail
+{
+  template<typename Function_T, bool IsMethod>
+  class NativeFunction
+  {
+  public:
+    // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
+    // have the concept of constants anyways
+    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
+    using Self_T = typename method_traits<Function_T, IsMethod>::Self_T;
+    using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
+    using From_Ruby_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+
+    // Static member function that Ruby calls
+    static VALUE call(int argc, VALUE* argv, VALUE self);
+
+  public:
+    NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo);
+
+    // Invokes the wrapped function
+    VALUE operator()(int argc, VALUE* argv, VALUE self);
+
+  private:
+    template<typename T, std::size_t I>
+    From_Ruby<T> createFromRuby();
+      
+    // Create NativeArgs which are used to convert values from Ruby to C++
+    template<std::size_t...I>
+    From_Ruby_Ts createFromRuby(std::index_sequence<I...>& indices);
+
+    To_Ruby<Return_T> createToRuby();
+      
+    // Convert Ruby argv pointer to Ruby values
+    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
+
+    // Convert Ruby values to C++ values
+    template<typename std::size_t...I>
+    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
+
+    // Figure out what self is
+    Self_T getSelf(VALUE self);
+
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
+
+    // Call the underlying C++ function
+    VALUE invokeNativeFunction(Arg_Ts& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs);
+
+  private:
+    Function_T func_;
+    From_Ruby_Ts fromRubys_;
+    To_Ruby<Return_T> toRuby_;
+    std::shared_ptr<Exception_Handler> handler_;
+    std::unique_ptr<MethodInfo> methodInfo_;
+  };
+}
+#include "NativeFunction.ipp"
+
+#endif // Rice__detail__Native_Function__hpp_

data/rice/detail/NativeFunction.ipp

@@ -0,0 +1,248 @@
+#include <array>
+#include <algorithm>
+#include <stdexcept>
+
+#include "method_data.hpp"
+#include "to_ruby_defn.hpp"
+#include "../ruby_try_catch.hpp"
+
+namespace Rice::detail
+{
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::call(int argc, VALUE* argv, VALUE self)
+  {
+    using Wrapper_T = NativeFunction<Function_T, IsMethod>;
+    Wrapper_T* wrapper = detail::MethodData::data<Wrapper_T*>();
+    return wrapper->operator()(argc, argv, self);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  NativeFunction<Function_T, IsMethod>::NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo)
+    : func_(func), handler_(handler), methodInfo_(methodInfo)
+  {
+    // Create a tuple of NativeArgs that will convert the Ruby values to native values. For 
+    // builtin types NativeArgs will keep a copy of the native value so that it 
+    // can be passed by reference or pointer to the native function. For non-builtin types
+    // it will just pass the value through.
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    this->fromRubys_ = this->createFromRuby(indices);
+
+    this->toRuby_ = this->createToRuby();
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<typename T, std::size_t I>
+  From_Ruby<T> NativeFunction<Function_T, IsMethod>::createFromRuby()
+  {
+    // Does the From_Ruby instantiation work with Arg?
+    if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
+    {
+      return From_Ruby<T>(&this->methodInfo_->arg(I));
+    }
+    else
+    {
+      return From_Ruby<T>();
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  To_Ruby<typename NativeFunction<Function_T, IsMethod>::Return_T> NativeFunction<Function_T, IsMethod>::createToRuby()
+  {
+    // Does the From_Ruby instantiation work with ReturnInfo?
+    if constexpr (std::is_constructible_v<To_Ruby<Return_T>, Return*>)
+    {
+      return To_Ruby<Return_T>(&this->methodInfo_->returnInfo);
+    }
+    else
+    {
+      return To_Ruby<Return_T>();
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  typename NativeFunction<Function_T, IsMethod>::From_Ruby_Ts NativeFunction<Function_T, IsMethod>::createFromRuby(std::index_sequence<I...>& indices)
+  {
+    return std::make_tuple(createFromRuby<remove_cv_recursive_t<typename std::tuple_element<I, Arg_Ts>::type>, I>()...);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  std::vector<VALUE> NativeFunction<Function_T, IsMethod>::getRubyValues(int argc, VALUE* argv)
+  {
+    // Setup a tuple to contain required methodInfo to rb_scan_args
+    std::string scanFormat = this->methodInfo_->formatString();
+    std::tuple<int, VALUE*, const char*> rbScanMandatory = std::forward_as_tuple(argc, argv, scanFormat.c_str());
+
+    // Create a vector to store the variable number of Ruby Values
+    std::vector<VALUE> rbScanArgsOptional(std::tuple_size_v<Arg_Ts>, Qnil);
+
+    // Convert the vector to an array so it can then be concatenated to a tuple
+    std::array<VALUE*, std::tuple_size_v<Arg_Ts>> rbScanArgsOptionalPointers;
+    std::transform(rbScanArgsOptional.begin(), rbScanArgsOptional.end(), rbScanArgsOptionalPointers.begin(),
+      [](VALUE& value)
+      {
+        return &value;
+      });
+
+    // Combine the tuples and call rb_scan_args
+    auto rbScanArgs = std::tuple_cat(rbScanMandatory, rbScanArgsOptionalPointers);
+    std::apply(rb_scan_args, rbScanArgs);
+
+    return rbScanArgsOptional;
+  }
+
+  template<typename Function_T, bool IsMethod>
+  template<std::size_t... I>
+  typename NativeFunction<Function_T, IsMethod>::Arg_Ts NativeFunction<Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
+     std::index_sequence<I...>& indices)
+  {
+    // Convert each Ruby value to its native value by calling the appropriate fromRuby instance.
+    // Note that for fundamental types From_Ruby<Arg_Ts> will keep a copy of the native value
+    // so it can be passed by reference or pointer to a native function.
+    return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(values[I])...);
+  }
+
+  template<typename Function_T, bool IsMethod>
+  typename NativeFunction<Function_T, IsMethod>::Self_T NativeFunction<Function_T, IsMethod>::getSelf(VALUE self)
+  {
+    // There is no self parameter
+    if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
+    {
+      return nullptr;
+    }
+    // Self parameter is a Ruby VALUE so no conversion is needed
+    else if constexpr (std::is_same_v<Self_T, VALUE>)
+    {
+      return self;
+    }
+    // Self parameter could be derived from Object or it is an C++ instdance and
+    // needs to be unwrapped from Ruby
+    else
+    {
+      return From_Ruby<Self_T>().convert(self);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeFunction(Arg_Ts& nativeArgs)
+  {
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->func_, nativeArgs);
+      return Qnil;
+    }
+    else
+    {
+      // Call the native method and get the result
+      Return_T nativeResult = std::apply(this->func_, nativeArgs);
+      
+      // Return the result
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs)
+  {
+    Self_T receiver = this->getSelf(self);
+    auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), nativeArgs);
+
+    if constexpr (std::is_void_v<Return_T>)
+    {
+      std::apply(this->func_, selfAndNativeArgs);
+      return Qnil;
+    }
+    else
+    {
+      Return_T nativeResult = (Return_T)std::apply(this->func_, selfAndNativeArgs);
+
+      // Special handling if the method returns self. If so we do not want
+      // to create a new Ruby wrapper object and instead return self.
+      if constexpr (std::is_same_v<intrinsic_type<Return_T>, intrinsic_type<Self_T>>)
+      {
+        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Self_T>)
+        {
+          if (nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Self_T>)
+        {
+          if (nativeResult == &receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Self_T>)
+        {
+          if (&nativeResult == receiver)
+            return self;
+        }
+        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Self_T>)
+        {
+          if (&nativeResult == &receiver)
+            return self;
+        }
+      }
+
+      return this->toRuby_.convert(nativeResult);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  void NativeFunction<Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues)
+  {
+    // Check function arguments
+    Wrapper* selfWrapper = getWrapper(self);
+    for (const Arg& arg : (*this->methodInfo_))
+    {
+      if (arg.isKeepAlive)
+      {
+        selfWrapper->addKeepAlive(rubyValues[arg.position]);
+      }
+    }
+
+    // Check return value
+    if (this->methodInfo_->returnInfo.isKeepAlive)
+    {
+      Wrapper* returnWrapper = getWrapper(returnValue);
+      returnWrapper->addKeepAlive(self);
+    }
+  }
+
+  template<typename Function_T, bool IsMethod>
+  VALUE NativeFunction<Function_T, IsMethod>::operator()(int argc, VALUE* argv, VALUE self)
+  {
+    try
+    {
+      // Get the ruby values
+      std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv);
+
+      auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+
+      // Convert the Ruby values to native values
+      Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+
+      // Now call the native method
+      VALUE result = Qnil;
+      if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
+      {
+        result = this->invokeNativeFunction(nativeValues);
+      }
+      else
+      {
+        result = this->invokeNativeMethod(self, nativeValues);
+      }
+
+      // Check if any function arguments or return values need to have their lifetimes tied to the receiver
+      this->checkKeepAlive(self, result, rubyValues);
+
+      return result;
+    }
+    catch (...)
+    {
+      RUBY_TRY
+      {
+        return this->handler_->handle_exception();
+      }
+      RUBY_CATCH
+    }
+  }
+}

data/rice/detail/RubyFunction.hpp

@@ -0,0 +1,39 @@
+#ifndef Rice__detail__ruby_function__hpp_
+#define Rice__detail__ruby_function__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice::detail
+{
+  /* This is functor class that wraps calls to a Ruby C API method. It is needed because
+     rb_protect only supports calling methods that take one argument. Thus 
+     we invoke rb_protect telling it to invoke Ruby_Function::call with an 
+     instance of a Ruby_Function. That instance then in turn calls the original
+     Ruby method passing along its required arguments. */
+
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  class RubyFunction
+  {
+  public:
+    RubyFunction(Function_T func, const Arg_Ts&... args);
+    Return_T operator()();
+
+  private:
+    Function_T func_;
+    std::tuple<Arg_Ts...> args_;
+  };
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args);
+}
+
+namespace Rice
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  [[deprecated("Please use detail::protect")]]
+  Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args);
+}
+
+#include "RubyFunction.ipp"
+
+#endif // Rice__detail__ruby_function__hpp_

data/rice/detail/RubyFunction.ipp

@@ -0,0 +1,92 @@
+#include "Jump_Tag.hpp"
+#include "../Exception_defn.hpp"
+
+#include <any>
+
+namespace Rice::detail
+{
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  inline RubyFunction<Function_T, Return_T, Arg_Ts...>::RubyFunction(Function_T func, const Arg_Ts&... args)
+    : func_(func), args_(std::forward_as_tuple(args...))
+  {
+  }
+
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  inline Return_T RubyFunction<Function_T, Return_T, Arg_Ts...>::operator()()
+  {
+    const int TAG_RAISE = 0x6; // From Ruby header files
+    int state = 0;
+
+    // Setup a thread local variable to capture the result of the Ruby function call.
+    // We use thread_local because the lambda has to be captureless so it can
+    // be converted to a function pointer callable by C.
+    // The thread local variable avoids having to cast the result to VALUE and then 
+    // back again to Return_T. The problem with that is the translation is not lossless
+    // in some cases - for example a double with value of -1.0 does not roundrip.
+    // 
+    thread_local std::any result;
+
+    // Callback that will invoke the Ruby function
+    using Functor_T = RubyFunction<Function_T, Return_T, Arg_Ts...>;
+    auto callback = [](VALUE value)
+    {
+      Functor_T* functor = (Functor_T*)value;
+
+      if constexpr (std::is_same_v<Return_T, void>)
+      {
+        std::apply(functor->func_, functor->args_);
+      }
+      else
+      {
+        result = std::apply(functor->func_, functor->args_);
+      }
+
+      return Qnil;
+    };
+
+    // Now call rb_protect which will invoke the callback lambda above
+    rb_protect(callback, (VALUE)this, &state);
+
+    // Did anything go wrong?
+    if (state == 0)
+    {
+      if constexpr (!std::is_same_v<Return_T, void>)
+      {
+        return std::any_cast<Return_T>(result);
+      }
+    }
+    else
+    {
+      VALUE err = rb_errinfo();
+      if (state == TAG_RAISE && RTEST(err))
+      {
+        rb_set_errinfo(Qnil);
+        throw Rice::Exception(err);
+      }
+      else
+      {
+        throw Jump_Tag(state);
+      }
+    }
+  }
+    
+  // Create a functor for calling a Ruby function and define some aliases for readability.
+  template<typename Return_T, typename ...Arg_Ts>
+  inline Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args)
+  {
+    using Function_T = Return_T(*)(Arg_Ts...);
+    auto rubyFunction = RubyFunction<Function_T, Return_T, Arg_Ts...>(func, args...);
+    return rubyFunction();
+  }
+}
+
+namespace Rice
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  inline Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args)
+  {
+    using Function_T = Return_T(*)(Arg_Ts...);
+    auto rubyFunction = detail::RubyFunction<Function_T, Return_T, Arg_Ts...>(func, args...);
+    return rubyFunction();
+  }
+}

data/rice/detail/Type.hpp

@@ -0,0 +1,29 @@
+#ifndef Rice__Type__hpp_
+#define Rice__Type__hpp_
+
+#include <string>
+#include <typeinfo>
+#include "rice_traits.hpp"
+
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type
+  {
+    static bool verify();
+  };
+
+  // Return the name of a type
+  std::string typeName(const std::type_info& typeInfo);
+  std::string makeClassName(const std::type_info& typeInfo);
+
+  template<typename T>
+  void verifyType();
+
+  template<typename Tuple_T>
+  void verifyTypes();
+}
+
+#include "Type.ipp"
+
+#endif // Rice__Type__hpp_

data/rice/detail/Type.ipp

@@ -0,0 +1,138 @@
+#include "rice_traits.hpp"
+
+#include <iosfwd>
+#include <numeric>
+#include <regex>
+#include <sstream>
+#include <tuple>
+
+#ifdef __GNUC__
+#include <cxxabi.h>
+#include <cstdlib>
+#include <cstring>
+#endif
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<void>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<typename T>
+  void verifyType()
+  {
+    Type<intrinsic_type<T>>::verify();
+  }
+
+  template<typename Tuple_T, size_t...Is>
+  void verifyTypesImpl()
+  {
+    (Type<intrinsic_type<typename std::tuple_element<Is, Tuple_T>::type>>::verify(), ...);
+  }
+
+  template<typename Tuple_T>
+  void verifyTypes()
+  {
+    if constexpr (std::tuple_size<Tuple_T>::value > 0)
+    {
+      verifyTypesImpl<Tuple_T, std::tuple_size<Tuple_T>::value - 1>();
+    }
+  }
+
+  inline std::string demangle(char const* mangled_name)
+  {
+#ifdef __GNUC__
+    struct Helper
+    {
+      Helper(
+        char const* mangled_name)
+        : name_(0)
+      {
+        int status = 0;
+        name_ = abi::__cxa_demangle(mangled_name, 0, 0, &status);
+      }
+
+      ~Helper()
+      {
+        std::free(name_);
+      }
+
+      char* name_;
+
+    private:
+      Helper(Helper const&);
+      void operator=(Helper const&);
+    };
+
+    Helper helper(mangled_name);
+    if (helper.name_)
+    {
+      return helper.name_;
+    }
+    else
+    {
+      return mangled_name;
+    }
+#else
+    return mangled_name;
+#endif
+  }
+
+  inline std::string typeName(const std::type_info& typeInfo)
+  {
+    return demangle(typeInfo.name());
+  }
+
+  inline std::string makeClassName(const std::type_info& typeInfo)
+  {
+    std::string base = demangle(typeInfo.name());
+
+    // Remove class keyword
+    auto classRegex = std::regex("class +");
+    base = std::regex_replace(base, classRegex, "");
+
+    // Remove struct keyword
+    auto structRegex = std::regex("struct +");
+    base = std::regex_replace(base, structRegex, "");
+
+    // Remove std::__[^:]*::
+    auto stdClangRegex = std::regex("std::__[^:]+::");
+    base = std::regex_replace(base, stdClangRegex, "");
+      
+    // Remove std::
+    auto stdRegex = std::regex("std::");
+    base = std::regex_replace(base, stdRegex, "");
+
+    // Replace > > 
+    auto trailingAngleBracketSpaceRegex = std::regex(" >");
+    base = std::regex_replace(base, trailingAngleBracketSpaceRegex, ">");
+
+    // Replace < and >
+    auto angleBracketRegex = std::regex("<|>");
+    base = std::regex_replace(base, angleBracketRegex, "__");
+
+    // Replace ,
+    auto commaRegex = std::regex(", *");
+    base = std::regex_replace(base, commaRegex, "_");
+
+    // Now create a vector of strings split on whitespace
+    std::istringstream stream(base);
+    std::vector<std::string> words{ std::istream_iterator<std::string>{stream},
+                                    std::istream_iterator<std::string>{} };
+
+    std::string result = std::accumulate(words.begin(), words.end(), std::string(),
+      [](const std::string& memo, const std::string& word) -> std::string
+      {
+        std::string capitalized = word;
+        capitalized[0] = toupper(capitalized[0]);
+        return memo + capitalized;
+      });
+
+    return result;
+  }
+}