Добавлено больше функций для строк

src/main/java/com/annimon/ownlang/lib/Converters.java

@@ -1,5 +1,6 @@
 package com.annimon.ownlang.lib;
 
+import java.util.function.Predicate;
 import static com.annimon.ownlang.lib.ValueUtils.getFloatNumber;
 
 /**
@@ -192,4 +193,11 @@ public final class Converters {
             return NumberValue.ZERO;
         });
     }
+
+    public static FunctionValue stringToBoolean(Predicate<String> f) {
+        return new FunctionValue(args -> {
+            Arguments.check(1, args.length);
+            return NumberValue.fromBoolean(f.test(args[0].asString()));
+        });
+    }
 }

src/main/java/com/annimon/ownlang/lib/StringValue.java

@@ -23,10 +23,38 @@ public final class StringValue implements Value {
             // Properties
             case "length":
                 return NumberValue.of(length());
+            case "lower":
+                return new StringValue(value.toLowerCase());
+            case "upper":
+                return new StringValue(value.toUpperCase());
+            case "chars": {
+                final Value[] chars = new Value[length()];
+                int i = 0;
+                for (char ch : value.toCharArray()) {
+                    chars[i++] = NumberValue.of((int) ch);
+                }
+                return new ArrayValue(chars);
+            }
 
             // Functions
             case "trim":
-                return new FunctionValue(args -> new StringValue(value.trim()));
+                return Converters.voidToString(value::trim);
+            case "startsWith":
+                return new FunctionValue(args -> {
+                    Arguments.checkOrOr(1, 2, args.length);
+                    int offset = (args.length == 2) ? args[1].asInt() : 0;
+                    return NumberValue.fromBoolean(value.startsWith(args[0].asString(), offset));
+                });
+            case "endsWith":
+                return Converters.stringToBoolean(value::endsWith);
+            case "matches":
+                return Converters.stringToBoolean(value::matches);
+            case "contains":
+                return Converters.stringToBoolean(value::contains);
+            case "equalsIgnoreCase":
+                return Converters.stringToBoolean(value::equalsIgnoreCase);
+            case "isEmpty":
+                return Converters.voidToBoolean(value::isEmpty);
 
             default:
                 if (Functions.isExists(prop)) {

src/test/resources/other/stringFunctions.own

@@ -9,6 +9,41 @@ def testTrim() {
   assertEquals("test", s.trim())
 }
 
+def testLower() {
+  s = "TeST"
+  assertEquals("test", s.lower)
+}
+
+def testUpper() {
+  s = "Test"
+  assertEquals("TEST", s.upper)
+}
+
+def testChars() {
+  assertEquals([49, 50, 51, 52], "1234".chars)
+}
+
+def testStartsWith() {
+  s = "test"
+  assertTrue(s.startsWith("tes"))
+  assertTrue(s.startsWith("t"))
+  assertFalse(s.startsWith("s"))
+}
+
+def testEndsWith() {
+  s = "test"
+  assertTrue(s.endsWith("st"))
+  assertTrue(s.endsWith("t"))
+  assertFalse(s.endsWith("s"))
+}
+
+def testIsEmpty() {
+  assertFalse("    ".isEmpty())
+  assertTrue("    ".trim().isEmpty())
+  assertFalse("1234".isEmpty())
+  assertTrue("".isEmpty())
+}
+
 def testExtensionFunction() {
   use "std"
   s = "1es1"