(stdlib) Return non-const strings

As elaborated on in
https://gitlab.perlang.org/perlang/perlang/-/merge_requests/538,
returning `const` strings can be a bit limiting. This is probably not a
good way to write idiomatic C++ code; I'll readily admit that I haven't
done much C++ programming in the last 20 years.

This change adjusts all return types to use non-`const` strings instead.
The caller can then cast the `unique_ptr<String>` etc. instances to a
`const` value as needed, but the other way around is much more awkward.

https://gitlab.perlang.org/perlang/perlang/-/merge_requests/544

release-notes/v0.6.0.md

@@ -36,6 +36,7 @@
 - De-duplicate string concatenation operator implementations [[!536][536]]
 - Avoid unnecessary `strdup()` call in `stdlib_wrappers.cc` [[!538][538]]
 - Fix bug in string comparison of dynamic strings [[!540][540]]
+- Return non-`const` strings [[!544][544]]
 
 #### CI
 - Add `dotnet test` CI job [[!499][499]]
@@ -119,3 +120,4 @@
 [541]: https://gitlab.perlang.org/perlang/perlang/merge_requests/541
 [542]: https://gitlab.perlang.org/perlang/perlang/merge_requests/542
 [543]: https://gitlab.perlang.org/perlang/perlang/merge_requests/543
+[544]: https://gitlab.perlang.org/perlang/perlang/merge_requests/544

src/stdlib/src/ascii_string.cc

@@ -9,7 +9,7 @@
 
 namespace perlang
 {
-    std::unique_ptr<const ASCIIString> ASCIIString::from_static_string(const char* str)
+    std::unique_ptr<ASCIIString> ASCIIString::from_static_string(const char* str)
     {
         if (str == nullptr) {
             throw std::invalid_argument("string argument cannot be null");
@@ -21,7 +21,7 @@ namespace perlang
         return std::unique_ptr<ASCIIString>(result);
     }
 
-    std::unique_ptr<const ASCIIString> ASCIIString::from_owned_string(const char* str, size_t length)
+    std::unique_ptr<ASCIIString> ASCIIString::from_owned_string(const char* str, size_t length)
     {
         if (str == nullptr) {
             throw std::invalid_argument("str argument cannot be null");
@@ -32,7 +32,7 @@ namespace perlang
         return std::unique_ptr<ASCIIString>(result);
     }
 
-    std::unique_ptr<const ASCIIString> ASCIIString::from_copied_string(const char* str)
+    std::unique_ptr<ASCIIString> ASCIIString::from_copied_string(const char* str)
     {
         if (str == nullptr) {
             throw std::invalid_argument("str argument cannot be null");
@@ -111,7 +111,7 @@ namespace perlang
         }
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(const String& rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(const String& rhs) const
     {
         size_t length = this->length_ + rhs.length();
         char *bytes = new char[length + 1];
@@ -124,7 +124,7 @@ namespace perlang
         return from_owned_string(bytes, length);
     }
 
-    std::unique_ptr<const ASCIIString> ASCIIString::operator+(const ASCIIString& rhs) const
+    std::unique_ptr<ASCIIString> ASCIIString::operator+(const ASCIIString& rhs) const
     {
         // Copy-paste is a bit ugly, but the alternative would perhaps also not be so pretty, calling the above method
         // and doing some semi-ugly casting of the result.
@@ -139,37 +139,37 @@ namespace perlang
         return from_owned_string(bytes, length);
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(int64_t rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(int64_t rhs) const
     {
         std::string str = std::to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(uint64_t rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(uint64_t rhs) const
     {
         std::string str = std::to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(float rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(float rhs) const
     {
         std::string str = internal::float_to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(double rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(double rhs) const
     {
         std::string str = internal::double_to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(const BigInt& rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(const BigInt& rhs) const
     {
         std::string str = rhs.to_string();
         return *this + str;
     }
 
-    std::unique_ptr<const String> ASCIIString::operator+(const std::string& rhs) const
+    std::unique_ptr<String> ASCIIString::operator+(const std::string& rhs) const
     {
         size_t length = this->length_ + rhs.length();
         char *bytes = new char[length + 1];

src/stdlib/src/ascii_string.h

@@ -22,19 +22,19 @@ namespace perlang
         // parameter "borrow" the actual bytes_ used by the string. Since no deallocation will take place, and no
         // mutation, copying the string at this point would just waste CPU cycles for no added benefit.
         [[nodiscard]]
-        static std::unique_ptr<const ASCIIString> from_static_string(const char* str);
+        static std::unique_ptr<ASCIIString> from_static_string(const char* str);
 
         // Creates a new ASCIIString from an "owned str", like a str that has been allocated on the heap. The
         // ownership of the memory is transferred to the ASCIIString, which is then responsible for deallocating the
         // memory when it is no longer needed (i.e. when no references to it remains).
         [[nodiscard]]
-        static std::unique_ptr<const ASCIIString> from_owned_string(const char* str, size_t length);
+        static std::unique_ptr<ASCIIString> from_owned_string(const char* str, size_t length);
 
         // Creates a new ASCIIString from an existing string, by copying its content to a new buffer allocated on the
         // heap. The ASCIIString class takes ownership of the newly allocated buffer, which will be deallocated when the
         // ASCIIString runs out of scope.
         [[nodiscard]]
-        static std::unique_ptr<const ASCIIString> from_copied_string(const char* str);
+        static std::unique_ptr<ASCIIString> from_copied_string(const char* str);
 
      private:
         // Private constructor for creating a new ASCIIString from a C-style (NUL-terminated) string. The `owned`
@@ -75,49 +75,49 @@ namespace perlang
 
         // Concatenates this string with another string. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(const String& rhs) const override;
+        std::unique_ptr<String> operator+(const String& rhs) const override;
 
         // Concatenates this string with another string. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const ASCIIString> operator+(const ASCIIString& rhs) const;
+        std::unique_ptr<ASCIIString> operator+(const ASCIIString& rhs) const;
 
         // Concatenates this string with an int32. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        inline std::unique_ptr<const String> operator+(int32_t rhs) const override
+        inline std::unique_ptr<String> operator+(int32_t rhs) const override
         {
             return this->operator+(static_cast<int64_t>(rhs));
         }
 
         // Concatenates this string with an int64. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(int64_t rhs) const override;
+        std::unique_ptr<String> operator+(int64_t rhs) const override;
 
         // Concatenates this string with a uint32. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        inline std::unique_ptr<const String> operator+(uint32_t rhs) const override
+        inline std::unique_ptr<String> operator+(uint32_t rhs) const override
         {
             return this->operator+(static_cast<uint64_t>(rhs));
         }
 
         // Concatenates this string with a uint64. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(uint64_t rhs) const override;
+        std::unique_ptr<String> operator+(uint64_t rhs) const override;
 
         // Concatenates this string with a float. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(float rhs) const override;
+        std::unique_ptr<String> operator+(float rhs) const override;
 
         // Concatenates this string with a double. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(double rhs) const override;
+        std::unique_ptr<String> operator+(double rhs) const override;
 
         // Concatenates this string with a BigInt. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        std::unique_ptr<const String> operator+(const BigInt& rhs) const override;
+        std::unique_ptr<String> operator+(const BigInt& rhs) const override;
 
         // Concatenates this string with a std::string. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        inline std::unique_ptr<const String> operator+(const std::string& rhs) const;
+        inline std::unique_ptr<String> operator+(const std::string& rhs) const;
 
      private:
         // The backing byte array for this string. This is to be considered immutable and MUST NOT be modified at any

src/stdlib/src/perlang_stdlib.h

@@ -31,8 +31,11 @@ namespace perlang
     // for all the existing String types instead of just receiving `const String`-type parameters.
     void print(const String* str);
     void print(const ASCIIString& str);
+    void print(const std::unique_ptr<String>& str);
     void print(const std::unique_ptr<const String>& str);
+    void print(const std::unique_ptr<ASCIIString>& str);
     void print(const std::unique_ptr<const ASCIIString>& str);
+    void print(const std::unique_ptr<UTF8String>& str);
     void print(const std::unique_ptr<const UTF8String>& str);
     void print(const std::shared_ptr<const String>& str);
     void print(const std::shared_ptr<const UTF8String>& str);

src/stdlib/src/perlang_string.h

@@ -29,40 +29,40 @@ namespace perlang
 
         // Concatenate this string with another string. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(const String& rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(const String& rhs) const = 0;
 
         // Concatenates this string with an int32. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(int32_t rhs) const
+        virtual std::unique_ptr<String> operator+(int32_t rhs) const
         {
             return this->operator+(static_cast<int64_t>(rhs));
         }
 
         // Concatenates this string with an int64. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(int64_t rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(int64_t rhs) const = 0;
 
         // Concatenates this string with a uint32. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(uint32_t rhs) const
+        virtual std::unique_ptr<String> operator+(uint32_t rhs) const
         {
             return this->operator+(static_cast<uint64_t>(rhs));
         }
 
         // Concatenates this string with a uint64. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(uint64_t rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(uint64_t rhs) const = 0;
 
         // Concatenates this string with a float. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(float rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(float rhs) const = 0;
 
         // Concatenates this string with a double. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(double rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(double rhs) const = 0;
 
         // Concatenates this string with a BigInt. The memory for the new string is allocated from the heap.
         [[nodiscard]]
-        virtual std::unique_ptr<const String> operator+(const BigInt& rhs) const = 0;
+        virtual std::unique_ptr<String> operator+(const BigInt& rhs) const = 0;
     };
 }

src/stdlib/src/print.cc

@@ -31,16 +31,31 @@ namespace perlang
         print(&str);
     }
 
+    void print(const std::unique_ptr<String>& str)
+    {
+        print(str.get());
+    }
+
     void print(const std::unique_ptr<const String>& str)
     {
         print(str.get());
     }
 
+    void print(const std::unique_ptr<ASCIIString>& str)
+    {
+        print(str.get());
+    }
+
     void print(const std::unique_ptr<const ASCIIString>& str)
     {
         print(str.get());
     }
 
+    void print(const std::unique_ptr<UTF8String>& str)
+    {
+        print(str.get());
+    }
+
     void print(const std::unique_ptr<const UTF8String>& str)
     {
         print(str.get());

src/stdlib/src/utf8_string.cc

@@ -8,7 +8,7 @@
 
 namespace perlang
 {
-    std::unique_ptr<const UTF8String> UTF8String::from_static_string(const char* s)
+    std::unique_ptr<UTF8String> UTF8String::from_static_string(const char* s)
     {
         if (s == nullptr) {
             throw std::invalid_argument("string argument cannot be null");
@@ -30,7 +30,7 @@ namespace perlang
         return std::unique_ptr<UTF8String>(result);
     }
 
-    std::unique_ptr<const UTF8String> UTF8String::from_copied_string(const char* str)
+    std::unique_ptr<UTF8String> UTF8String::from_copied_string(const char* str)
     {
         if (str == nullptr) {
             throw std::invalid_argument("str argument cannot be null");
@@ -99,7 +99,7 @@ namespace perlang
         return !(rhs == *this);
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(const String& rhs) const
+    std::unique_ptr<String> UTF8String::operator+(const String& rhs) const
     {
         size_t length = this->length_ + rhs.length();
         char *bytes = new char[length + 1];
@@ -112,7 +112,7 @@ namespace perlang
         return from_owned_string(bytes, length);
     }
 
-    std::unique_ptr<const UTF8String> UTF8String::operator+(const UTF8String& rhs) const
+    std::unique_ptr<UTF8String> UTF8String::operator+(const UTF8String& rhs) const
     {
         size_t length = this->length_ + rhs.length();
         char *bytes = new char[length + 1];
@@ -124,31 +124,31 @@ namespace perlang
         return from_owned_string(bytes, length);
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(const int64_t rhs) const
+    std::unique_ptr<String> UTF8String::operator+(const int64_t rhs) const
     {
         std::string str = std::to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(const uint64_t rhs) const
+    std::unique_ptr<String> UTF8String::operator+(const uint64_t rhs) const
     {
         std::string str = std::to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(float rhs) const
+    std::unique_ptr<String> UTF8String::operator+(float rhs) const
     {
         std::string str = internal::float_to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(double rhs) const
+    std::unique_ptr<String> UTF8String::operator+(double rhs) const
     {
         std::string str = internal::double_to_string(rhs);
         return *this + str;
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(const std::string& rhs) const
+    std::unique_ptr<String> UTF8String::operator+(const std::string& rhs) const
     {
         size_t length = this->length_ + rhs.length();
         char *bytes = new char[length + 1];
@@ -160,37 +160,37 @@ namespace perlang
         return from_owned_string(bytes, length);
     }
 
-    std::unique_ptr<const String> UTF8String::operator+(const BigInt& rhs) const
+    std::unique_ptr<String> UTF8String::operator+(const BigInt& rhs) const
     {
         std::string str = rhs.to_string();
         return *this + str;
     }
 
-    std::unique_ptr<const UTF8String> operator+(const int64_t lhs, const UTF8String& rhs)
+    std::unique_ptr<UTF8String> operator+(const int64_t lhs, const UTF8String& rhs)
     {
         std::string str = std::to_string(lhs);
         return str + rhs;
     }
 
-    std::unique_ptr<const UTF8String> operator+(const uint64_t lhs, const UTF8String& rhs)
+    std::unique_ptr<UTF8String> operator+(const uint64_t lhs, const UTF8String& rhs)
     {
         std::string str = std::to_string(lhs);
         return str + rhs;
     }
 
-    std::unique_ptr<const UTF8String> operator+(const float lhs, const UTF8String& rhs)
+    std::unique_ptr<UTF8String> operator+(const float lhs, const UTF8String& rhs)
     {
         std::string str = internal::float_to_string(lhs);
         return str + rhs;
     }
 
-    std::unique_ptr<const UTF8String> operator+(const double lhs, const UTF8String& rhs)
+    std::unique_ptr<UTF8String> operator+(const double lhs, const UTF8String& rhs)
     {
         std::string str = internal::double_to_string(lhs);
         return str + rhs;
     }
 
-    std::unique_ptr<const UTF8String> operator+(const std::string& lhs, const UTF8String& rhs)
+    std::unique_ptr<UTF8String> operator+(const std::string& lhs, const UTF8String& rhs)
     {
         size_t length = lhs.length() + rhs.length();
         char *bytes = new char[length + 1];