Add function support to skrypt

Co-Authored-By: Serg Kryvonos <[email protected]>

Author: devin-ai-integration[bot]

libskrypt/skrypt.cpp

@@ -159,6 +159,10 @@ bool Skrypt::Add(std::string_view line) {
     return Add(v);
 }
 
+bool Skrypt::Add(const ::omnn::math::Variable& var, ::omnn::math::Valuable&& val) {
+    return base::Add(var, std::move(val));
+}
+
 namespace {
 	std::string Questionless(std::string s) {
 		s.erase(std::remove(s.begin(), s.end(), '?'), s.end());
@@ -170,6 +174,132 @@ namespace {
 	auto FindBracePos(std::string_view line) {
 		return line.find_first_of("{}[]"sv);
 	}
+    
+    bool IsFunctionDefinition(std::string_view line) {
+        auto openParenPos = line.find('(');
+        if (openParenPos == std::string_view::npos) return false;
+        
+        auto closeParenPos = line.find(')', openParenPos);
+        if (closeParenPos == std::string_view::npos) return false;
+        
+        auto equalPos = line.find('=', closeParenPos);
+        if (equalPos == std::string_view::npos) return false;
+        
+        if (openParenPos == 0) return false;
+        
+        return true;
+    }
+    
+    bool IsFunctionApplication(std::string_view line) {
+        auto equalPos = line.find('=');
+        auto openParenPos = line.find('(');
+        
+        if (openParenPos == std::string_view::npos) return false;
+        
+        if (equalPos != std::string_view::npos && openParenPos < equalPos) return false;
+        
+        auto closeParenPos = line.find(')', openParenPos);
+        if (closeParenPos == std::string_view::npos) return false;
+        
+        if (openParenPos == 0) return false;
+        
+        return true;
+    }
+    
+    std::vector<std::string> ParseFunctionArgs(std::string_view argsStr) {
+        std::vector<std::string> args;
+        std::string currentArg;
+        
+        for (size_t i = 0; i < argsStr.size(); ++i) {
+            char c = argsStr[i];
+            if (c == ',') {
+                boost::algorithm::trim(currentArg);
+                if (!currentArg.empty()) {
+                    args.push_back(currentArg);
+                    currentArg.clear();
+                }
+            } else {
+                currentArg += c;
+            }
+        }
+        
+        boost::algorithm::trim(currentArg);
+        if (!currentArg.empty()) {
+            args.push_back(currentArg);
+        }
+        
+        return args;
+    }
+}
+
+bool Skrypt::ProcessFunctionDefinition(std::string_view& line)
+{
+    if (!IsFunctionDefinition(line)) {
+        return false;
+    }
+    
+    auto openParenPos = line.find('(');
+    auto closeParenPos = line.find(')', openParenPos);
+    auto equalPos = line.find('=', closeParenPos);
+    
+    std::string_view funcName = line.substr(0, openParenPos);
+    boost::algorithm::trim(funcName);
+    
+    std::string_view argsStr = line.substr(openParenPos + 1, closeParenPos - openParenPos - 1);
+    auto args = ParseFunctionArgs(argsStr);
+    
+    std::string_view exprStr = line.substr(equalPos + 1);
+    boost::algorithm::trim(exprStr);
+    
+    std::string lambdaExpr = std::string(exprStr);
+    
+    auto& funcVar = varHost->Host(std::string(funcName));
+    
+    std::string functionDef = "Function(";
+    functionDef += std::string(funcName);
+    functionDef += ", [";
+    for (size_t i = 0; i < args.size(); ++i) {
+        if (i > 0) functionDef += ", ";
+        functionDef += args[i];
+    }
+    functionDef += "], ";
+    functionDef += std::string(exprStr);
+    functionDef += ")";
+    
+    Add(funcVar, ::omnn::math::Valuable(functionDef, varHost));
+    
+    return true;
+}
+
+bool Skrypt::ProcessFunctionApplication(std::string_view& line)
+{
+    if (!IsFunctionApplication(line)) {
+        return false;
+    }
+    
+    auto equalPos = line.find('=');
+    std::string_view leftSide;
+    std::string_view rightSide;
+    
+    if (equalPos != std::string_view::npos) {
+        leftSide = line.substr(0, equalPos);
+        boost::algorithm::trim(leftSide);
+        rightSide = line.substr(equalPos + 1);
+    } else {
+        rightSide = line;
+    }
+    
+    boost::algorithm::trim(rightSide);
+    
+    if (equalPos != std::string_view::npos) {
+        auto& resultVar = varHost->Host(std::string(leftSide));
+        
+        Add(resultVar, ::omnn::math::Valuable(rightSide, varHost));
+    } else {
+        Add(::omnn::math::Valuable(rightSide, varHost));
+    }
+    
+    return true;
 }
 
 void Skrypt::ProcessQuestionLine(std::string_view& line)
@@ -332,6 +462,8 @@ bool Skrypt::ParseNextLine(std::istream& in, std::string_view& line)
 
         if (boost::algorithm::contains(line, "?")) {
             ProcessQuestionLine(line);
+        } else if (ProcessFunctionDefinition(line)) {
+        } else if (ProcessFunctionApplication(line)) {
         } else {
             Valuable expression;
             try {
@@ -676,4 +808,4 @@ Skrypt::Skrypt(const skrypt::Skrypt& that)
     , sourceFilePath(that.sourceFilePath)
     , moduleFileSearchAdditionalPaths(that.moduleFileSearchAdditionalPaths)
 {
-}
+}

libskrypt/skrypt.h

@@ -65,10 +65,13 @@ class Skrypt
 
     bool Add(::omnn::math::Valuable&&);
     bool Add(std::string_view);
+    bool Add(const ::omnn::math::Variable& var, ::omnn::math::Valuable&& val);
     bool ParseNextLine(std::istream&, std::string_view&);
     void PrintVarKnowns(const omnn::math::Variable&);
     void PrintAllKnowns();
     void ProcessQuestionLine(std::string_view&);
+    bool ProcessFunctionDefinition(std::string_view&);
+    bool ProcessFunctionApplication(std::string_view&);
 
     void BindTargetStream(std::ostream&);
     void BindTargetStream(std::shared_ptr<std::ostream>);

libskrypt/tests/TestFunction.skrypt

@@ -0,0 +1,5 @@
+f(x) = x^2
+y = f(2)
+g(x, y) = x*y + x^2
+z = g(2, 3)
+h = f(g(3, 1))

libskrypt/tests/TestFunctionSupport.cpp

@@ -0,0 +1,67 @@
+#define BOOST_TEST_MODULE skryptFunction test
+#include <boost/test/unit_test.hpp>
+#include "skrypt.h"
+
+using namespace ::skrypt;
+using namespace std::string_literals;
+using namespace std::string_view_literals;
+
+BOOST_AUTO_TEST_CASE(FunctionDefinitionTest) {
+    Skrypt skrypt;
+    
+    skrypt.Add("f(x) = x^2"sv);
+    
+    auto varhost = skrypt.GetVarHost();
+    auto& f = varhost->Host("f"s);
+    
+    auto& solutions = skrypt.Known(f);
+    BOOST_TEST(!solutions.empty());
+    
+    skrypt.Add("y = f(2)"sv);
+    auto& y = varhost->Host("y"s);
+    auto& ySolutions = skrypt.Known(y);
+    BOOST_TEST(ySolutions.size() == 1);
+    for (auto& solution : ySolutions) {
+        BOOST_TEST(solution == 4);
+    }
+    
+    skrypt.Add("z = 3"sv);
+    skrypt.Add("w = f(z)"sv);
+    auto& w = varhost->Host("w"s);
+    auto& wSolutions = skrypt.Known(w);
+    BOOST_TEST(wSolutions.size() == 1);
+    for (auto& solution : wSolutions) {
+        BOOST_TEST(solution == 9);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(MultipleArgumentFunctionTest) {
+    Skrypt skrypt;
+    
+    skrypt.Add("g(x, y) = x*y + x^2"sv);
+    
+    skrypt.Add("result = g(2, 3)"sv);
+    auto varhost = skrypt.GetVarHost();
+    auto& result = varhost->Host("result"s);
+    auto& resultSolutions = skrypt.Known(result);
+    BOOST_TEST(resultSolutions.size() == 1);
+    for (auto& solution : resultSolutions) {
+        BOOST_TEST(solution == 10); // 2*3 + 2^2 = 6 + 4 = 10
+    }
+}
+
+BOOST_AUTO_TEST_CASE(ComposedFunctionTest) {
+    Skrypt skrypt;
+    
+    skrypt.Add("f(x) = x^2"sv);
+    skrypt.Add("g(x) = 2*x + 1"sv);
+    
+    skrypt.Add("h = f(g(3))"sv);
+    auto varhost = skrypt.GetVarHost();
+    auto& h = varhost->Host("h"s);
+    auto& hSolutions = skrypt.Known(h);
+    BOOST_TEST(hSolutions.size() == 1);
+    for (auto& solution : hSolutions) {
+        BOOST_TEST(solution == 49); // f(g(3)) = f(2*3+1) = f(7) = 7^2 = 49
+    }
+}