[stdlib] String comparisons implemented

stdlib/src/builtin/string.mojo

@@ -734,6 +734,60 @@ struct String(
         """
         return not (self == other)
 
+    @always_inline
+    fn __lt__(self, rhs: String) -> Bool:
+        """Compare this String to the RHS using LT comparison.
+
+        Args:
+            rhs: The other String to compare against.
+
+        Returns:
+            True if this String is strictly less than the RHS String and False otherwise.
+        """
+        var len1 = len(self)
+        var len2 = len(rhs)
+
+        if len1 < len2:
+            return memcmp(self._as_ptr(), rhs._as_ptr(), len1) <= 0
+        else:
+            return memcmp(self._as_ptr(), rhs._as_ptr(), len2) < 0
+
+    @always_inline
+    fn __le__(self, rhs: String) -> Bool:
+        """Compare this String to the RHS using LE comparison.
+
+        Args:
+            rhs: The other String to compare against.
+
+        Returns:
+            True if this String is less than or equal to the RHS String and False otherwise.
+        """
+        return not (rhs < self)
+
+    @always_inline
+    fn __gt__(self, rhs: String) -> Bool:
+        """Compare this String to the RHS using GT comparison.
+
+        Args:
+            rhs: The other String to compare against.
+
+        Returns:
+            True if this String is strictly greater than the RHS String and False otherwise.
+        """
+        return rhs < self
+
+    @always_inline
+    fn __ge__(self, rhs: String) -> Bool:
+        """Compare this String to the RHS using GE comparison.
+
+        Args:
+            rhs: The other String to compare against.
+
+        Returns:
+            True if this String is greater than or equal to the RHS String and False otherwise.
+        """
+        return not (self < rhs)
+
     @always_inline
     fn __add__(self, other: String) -> String:
         """Creates a string by appending another string at the end.

stdlib/src/builtin/string_literal.mojo

@@ -129,6 +129,60 @@ struct StringLiteral(
         """
         return not self == rhs
 
+    @always_inline("nodebug")
+    fn __lt__(self, rhs: StringLiteral) -> Bool:
+        """Compare this StringLiteral to the RHS using LT comparison.
+
+        Args:
+            rhs: The other StringLiteral to compare against.
+
+        Returns:
+            True if this StringLiteral is strictly less than the RHS StringLiteral and False otherwise.
+        """
+        var len1 = len(self)
+        var len2 = len(rhs)
+
+        if len1 < len2:
+            return _memcmp(self.data(), rhs.data(), len1) <= 0
+        else:
+            return _memcmp(self.data(), rhs.data(), len2) < 0
+
+    @always_inline("nodebug")
+    fn __le__(self, rhs: StringLiteral) -> Bool:
+        """Compare this StringLiteral to the RHS using LE comparison.
+
+        Args:
+            rhs: The other StringLiteral to compare against.
+
+        Returns:
+            True if this StringLiteral is less than or equal to the RHS StringLiteral and False otherwise.
+        """
+        return not (rhs < self)
+
+    @always_inline("nodebug")
+    fn __gt__(self, rhs: StringLiteral) -> Bool:
+        """Compare this StringLiteral to the RHS using GT comparison.
+
+        Args:
+            rhs: The other StringLiteral to compare against.
+
+        Returns:
+            True if this StringLiteral is strictly greater than the RHS StringLiteral and False otherwise.
+        """
+        return rhs < self
+
+    @always_inline("nodebug")
+    fn __ge__(self, rhs: StringLiteral) -> Bool:
+        """Compare this StringLiteral to the RHS using GE comparison.
+
+        Args:
+            rhs: The other StringLiteral to compare against.
+
+        Returns:
+            True if this StringLiteral is greater than or equal to the RHS StringLiteral and False otherwise.
+        """
+        return not (self < rhs)
+
     fn __hash__(self) -> Int:
         """Hash the underlying buffer using builtin hash.
 

stdlib/test/builtin/test_string.mojo

@@ -98,6 +98,56 @@ fn test_equality_operators() raises:
     assert_not_equal(s0, "notabc")
 
 
+fn test_comparison_operators() raises:
+    var abc = String("abc")
+    var de = String("de")
+    var ABC = String("ABC")
+    var ab = String("ab")
+    var abcd = String("abcd")
+
+    # Test less than and greater than
+    assert_true(abc < de)
+    assert_false(de < abc)
+    assert_false(abc < abc)
+    assert_true(ab < abc)
+    assert_true(abc > ab)
+    assert_false(abc > abcd)
+
+    # Test less than or equal to and greater than or equal to
+    assert_true(abc <= de)
+    assert_true(abc <= abc)
+    assert_false(de <= abc)
+    assert_true(abc >= abc)
+    assert_false(ab >= abc)
+    assert_true(abcd >= abc)
+
+    # Test case sensitivity in comparison (assuming ASCII order)
+    assert_true(abc > ABC)
+    assert_false(abc <= ABC)
+
+    # Testing with implicit conversion
+    assert_true(abc < "defgh")
+    assert_false(abc > "xyz")
+    assert_true(abc >= "abc")
+    assert_false(abc <= "ab")
+
+    # Test against empty strings
+    assert_true(str("") < abc)
+    assert_false(abc < "")
+    assert_true(str("") <= "")
+    assert_true(str("") >= "")
+
+    # Test comparisons involving default constructed empty string
+    assert_true(String() < abc)
+    assert_false(abc < String())
+    assert_true(String() <= abc)
+    assert_false(abc <= String())
+    assert_true(String() <= "")
+    assert_true(String() >= "")
+    assert_false(abc <= String())
+    assert_true(String() >= String())
+
+
 fn test_add() raises:
     var s1 = String("123")
     var s2 = String("abc")
@@ -697,6 +747,7 @@ def main():
     test_constructors()
     test_copy()
     test_equality_operators()
+    test_comparison_operators()
     test_add()
     test_stringable()
     test_string_join()

stdlib/test/builtin/test_string_literal.mojo

@@ -78,6 +78,34 @@ def test_rfind():
     assert_equal(-1, "abc".rfind("abcd"))
 
 
+fn test_comparison_operators() raises:
+    # Test less than and greater than
+    assert_true("abc" < "def")
+    assert_false("def" < "abc")
+    assert_false("abc" < "abc")
+    assert_true("ab" < "abc")
+    assert_true("abc" > "ab")
+    assert_false("abc" > "abcd")
+
+    # Test less than or equal to and greater than or equal to
+    assert_true("abc" <= "def")
+    assert_true("abc" <= "abc")
+    assert_false("def" <= "abc")
+    assert_true("abc" >= "abc")
+    assert_false("ab" >= "abc")
+    assert_true("abcd" >= "abc")
+
+    # Test case sensitivity in comparison (assuming ASCII order)
+    assert_true("abc" > "ABC")
+    assert_false("abc" <= "ABC")
+
+    # Test against empty strings
+    assert_true("" < "abc")
+    assert_false("abc" < "")
+    assert_true("" <= "")
+    assert_true("" >= "")
+
+
 def test_hash():
     # Test a couple basic hash behaviors.
     # `test_hash.test_hash_bytes` has more comprehensive tests.
@@ -99,5 +127,6 @@ def main():
     test_contains()
     test_find()
     test_rfind()
+    test_comparison_operators()
     test_hash()
     test_intable()