diff --git a/query_language/classes.cpp b/query_language/classes.cpp
index 33ec39b5d3ff67a4e9f57f19c3f9e6d0e9c1beb0..1ac68dd6f8ef1872eb6c2911229f531ffdbe4e36 100644
--- a/query_language/classes.cpp
+++ b/query_language/classes.cpp
@@ -38,29 +38,14 @@ void logical_expr::accept(expr_visitor* visitor) {
     visitor->visit(this);
 }
 
-/*class func_expr : public expr {
-public:
-    expr* callee;
-    token paren;
-    std::vector<expr*> arguments;
-
-    func_expr(expr* c, token par, std::vector<expr*>& args);
-    virtual ~func_expr();
-    void accept(expr_visitor* visitor);
-};
-
-func_expr::func_expr(expr* c, token par, std::vector<expr*>& args) : callee(c), paren(par), arguments(args) {};
-func_expr::~func_expr() {
-    delete callee;
-    for (auto arg : arguments) {
-        delete arg;
-    }
+func_in::func_in(expr* l, expr* r) : left(l), right(r) {};
+func_in::~func_in() {
+    delete left;
+    delete right;
 }
-void func_expr::accept(expr_visitor* visitor){
+void func_in::accept(expr_visitor* visitor) {
     visitor->visit(this);
-}*/
-
-
+}
 
 grouping::grouping(expr* e) : expression(e) {};
 
diff --git a/query_language/classes.h b/query_language/classes.h
index 262064ff482d74839dc12f669858995b2a1bddca..f3d7f6433f162798908cc348aafd9a563ac0e891 100644
--- a/query_language/classes.h
+++ b/query_language/classes.h
@@ -5,7 +5,7 @@ class binary;
 class grouping;
 class unary;
 class logical_expr;
-class func_expr; 
+class func_in; 
 class literal;
 
 //enum value_type{BOOL, JSON, DOUBLE, EMPTY};
@@ -14,11 +14,13 @@ struct value{
     token_type val_type;
     bool bool_val;
     double doub_val;
+    std::string str_val;
     json json_val; 
     value() : val_type(EMPTY){}
     value(bool bool_val_) : val_type(BOOL), bool_val(bool_val_) {}
     value( json json_val_) : val_type(JSON), json_val(json_val_) {}
     value(double doub_val_) : val_type(DOUBLE), doub_val(doub_val_) {}
+    value(std::string str_val_) : val_type(STRING), str_val(str_val_) {}
 };
 
 
@@ -29,7 +31,7 @@ public:
     virtual void visit(unary* expr) = 0;
     virtual void visit(literal* expr) = 0;
     virtual void visit(logical_expr* expr) = 0;
- //   virtual void visit(func_expr* expr) = 0;
+    virtual void visit(func_in* expr) = 0;
     virtual void visit(grouping* expr) = 0;
 };
 
@@ -68,6 +70,18 @@ public:
 
 
 
+class func_in : public expr {
+public:
+    expr* left;
+    expr* right;
+
+    func_in(expr* l, expr* r);
+    virtual ~func_in();
+    void accept(expr_visitor* visitor);
+};
+
+
+
 class unary : public expr {
 public:
     expr* ex;
diff --git a/query_language/classes.o b/query_language/classes.o
new file mode 100644
index 0000000000000000000000000000000000000000..5386f451e21cbc5b4bc89432b15f5c246887d19f
Binary files /dev/null and b/query_language/classes.o differ
diff --git a/query_language/interpreter.cpp b/query_language/interpreter.cpp
index 90a002efafb62cad2a3f278d066c2c65ea630964..b4f141eade6d717f3427cf2bb4977470d708b089 100644
--- a/query_language/interpreter.cpp
+++ b/query_language/interpreter.cpp
@@ -102,10 +102,53 @@ void interpreter::visit(binary* expr){
 }
 
 void interpreter::visit(grouping* expr){
-    std::cout<<"grouping"<<std::endl;
     expr->expression->accept(this);
 }	
 
+
+void interpreter::visit(func_in* expr){
+    value left = evaluate(expr->left);
+    value right = evaluate(expr->right);
+    if (left.val_type == STRING && right.val_type == JSON){
+        result = value(find_word_inJson(left.str_val, right.json_val));
+    }
+
+
+}	
+
+bool interpreter::find_word_inJson(std::string word, json jsonValue){
+    if (jsonValue.is_string()) {
+        
+        return jsonValue.get<std::string>().find(word) != std::string::npos;
+    } else if (jsonValue.is_array()) {
+        
+        for (const auto& element : jsonValue) {
+            
+            if (find_word_inJson(element, word)) {
+                return true;
+            }
+        }
+    } else{
+        return false;
+    }
+    return false;
+
+    
+    /*else if (jsonValue.is_object()) {
+        // Если элемент JSON является объектом
+        for (const auto& [key, value] : jsonValue.items()) {
+            // Рекурсивно вызываем функцию для каждого значения объекта
+            if (find_word_inJson(value, word)) {
+                return true;
+            }
+        }*/
+
+    
+    
+}
+
+
+
 void interpreter::visit(unary* expr){
     value right = evaluate(expr->ex);
 
@@ -181,24 +224,7 @@ json interpreter::find_json_value(const json& card, std::vector<std::string> lev
     return current_json;
 }
 
-/*void interpreter::visit(expr_visitor* expr){
-    value callee = evaluate(expr->callee);
-
-    std::vector<value> arguments;
-    for (auto& a : expr->arguments){
-        arguments.emplace_back(evaluate(a));
-    }
-    if (callee.v_type != CALLABLE_VALUE)
-        throw lox_runtime_error(expr->paren, "Can only call functions and classes.");
 
-    lox_callable* function = callee.callable_value;
-    
-    if (arguments.size() > function->arity()){
-        throw lox_runtime_error(expr->paren, std::string("Expected " + std::to_string(function->arity()) +
-            " arguments, got " + std::to_string(arguments.size()) + " ."));
-    }
-    result = function->call(this, arguments);
-}*/
 
 
 void interpreter::visit(logical_expr* ex){
diff --git a/query_language/interpreter.h b/query_language/interpreter.h
index 8622744ff60475967a480b61a21276e977cb59b0..227eb9cf7122070c9a90c230c1516bedf39993fb 100644
--- a/query_language/interpreter.h
+++ b/query_language/interpreter.h
@@ -16,9 +16,9 @@ class interpreter : expr_visitor {
     void visit(grouping* expr);
     void visit(unary* expr);
     void visit(literal* expr);
-   // void visit(func_expr* expr);
+    void visit(func_in* expr);
     void visit(logical_expr* ex);
-    
+    bool find_word_inJson(std::string word, json jsonValue);
     void check_number_operand(token oper, value operand);
     void check_number_operands(token oper, value left, value right);
     json find_json_value(const json& card, std::vector<std::string>);
diff --git a/query_language/interpreter.o b/query_language/interpreter.o
new file mode 100644
index 0000000000000000000000000000000000000000..0307d4bc21b990cba92eadeee0ee1f002660a04f
Binary files /dev/null and b/query_language/interpreter.o differ
diff --git a/query_language/kod b/query_language/kod
new file mode 100755
index 0000000000000000000000000000000000000000..3d23b115deb3376a0ee2b416f239fd7bdae11326
Binary files /dev/null and b/query_language/kod differ
diff --git a/query_language/main.cpp b/query_language/main.cpp
index 635c03d3de87e901e963f759408d719926e848c6..08d10857b126c2429575839798a339cd88d41b01 100644
--- a/query_language/main.cpp
+++ b/query_language/main.cpp
@@ -30,7 +30,7 @@ json card_to_json(Card card){
 
 int main(){
     Card card;
-    card.word = "example aaaa";
+    card.word = "example";
     card.special = { "special1", "special2" };
     card.definition = "This is an example";
     card.examples = { "Example 1", "Example 2" };
@@ -56,7 +56,7 @@ int main(){
             std::cout<<"num"<<std::endl;
         }
     }*/
-    scanner scan("2*2 > 4 and 2 < 4");
+    scanner scan("\"example\" in(word) ");
     std::vector<token> tokens= scan.scan_tokens();
     /*for(int i = 0; i < tokens.size();++i){
         std::cout<<tokens[i].lexeme<<" "<<i<<std::endl;
@@ -74,6 +74,11 @@ int main(){
     } else if (val.val_type == BOOL){
         std::cout<<"это bool "<< std::endl;
         std::cout<<"значение: "<<val.bool_val<< std::endl;
+    } else if (val.val_type == STRING){
+        std::cout<<"это string "<< std::endl;
+        std::cout<<"значение: "<<val.str_val<< std::endl;
+    } else if (val.val_type == EMPTY){
+        std::cout<<"пусто"<< std::endl;
     } 
     delete exp;
     
diff --git a/query_language/main.o b/query_language/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..b1e1f32f651566db2aaad33f24647febf750c7ec
Binary files /dev/null and b/query_language/main.o differ
diff --git a/query_language/parcer.cpp b/query_language/parcer.cpp
index d2e0881e78ca8f0d82581d2e218708d4da739217..bf21d5f545afa5710d947c5cbf69dbee917c223f 100644
--- a/query_language/parcer.cpp
+++ b/query_language/parcer.cpp
@@ -77,27 +77,20 @@ std::vector<std::string> parser::read_json_elem(){
 }
 
 
-/*expr* parser::finish_call(expr* callee){
-    std::vector<expr*> arguments;
-    if (!check(tt::RIGHT_PAREN)){
-        do{
-            arguments.emplace_back(expression());
-        } while(match({tt::COMMA}));
+
+expr* parser::func_in_class(){
+    expr* left = primary();
+    if(match({tt::IN})){
+        if(match({tt::LEFT_PAREN})){
+            expr* right = primary();
+            if(match({tt::RIGHT_PAREN})){
+                return new func_in(left, right);
+            }
+        }
     }
-    token r_paren = consume(tt::RIGHT_PAREN, "Expect ')' after arguments.");
-    return new call_expr(callee, r_paren, arguments);
-}*/
+    return primary();
+}
 
-/*expr* parser::call(){
-    expr* call = primary();
-    while (true){
-        if (match({tt::LEFT_PAREN}))
-            call = finish_call(call);
-        else
-            break;
-    };
-    return call;
-}*/
 
 expr* parser::unar(){
     if(match({tt::BANG, tt::MINUS})){
@@ -105,7 +98,7 @@ expr* parser::unar(){
         expr* right = unar();
         return new unary(right, oper);
     }
-    return primary();
+    return func_in_class();
 }
 
 expr* parser::multiplication(){
diff --git a/query_language/parcer.h b/query_language/parcer.h
index 812182636ba0d81181e67336bafbf122998c5c00..dc71dc2398b5210c0278f39baef61264fc1e2bd8 100644
--- a/query_language/parcer.h
+++ b/query_language/parcer.h
@@ -19,7 +19,7 @@ class parser {
     token consume(token_type type, std::string message);
     expr* primary();
     expr* finish_call(expr* callee);
-    expr* call();
+    expr* func_in_class();
     expr* unar();
     expr* multiplication();
     expr* addition();
diff --git a/query_language/parcer.o b/query_language/parcer.o
new file mode 100644
index 0000000000000000000000000000000000000000..8995befdf9e6bb8c7b9e979acfba927fc0d7fe8a
Binary files /dev/null and b/query_language/parcer.o differ
diff --git a/query_language/scaner.o b/query_language/scaner.o
new file mode 100644
index 0000000000000000000000000000000000000000..c4e51769530fcc9ddc6f455c519a41bf31255142
Binary files /dev/null and b/query_language/scaner.o differ