diff --git a/extensions/standard/array.cpp b/extensions/standard/array.cpp
index 54f5420..e7ef51f 100644
--- a/extensions/standard/array.cpp
+++ b/extensions/standard/array.cpp
@@ -187,3 +187,76 @@ Value replace(const std::vector<Value>& args) {
     arr = result;
     return arr;
 }
+
+
+// 拼接给定的所有列表
+Value concat(const std::vector<Value>& args) {
+	std::vector<Value> result;
+	for (const auto &i : args) {
+		if (!i.is_array()) {
+			L_ERR("Given parameter(s) have no-array element");
+			return LAMINA_NULL;
+		}
+		for (const auto &j : std::get<std::vector<Value> >(i.data)) {
+			result.push_back(j);
+		}
+	}
+	return Value(result);
+}
+
+// 列表切片
+Value slice(const std::vector<Value>& args) {
+	check_cpp_function_argv_x(args, 3, 4);
+	if (!args[0].is_array()) {
+		L_ERR("slice() requires a list");
+		return LAMINA_NULL;
+	}
+	std::vector<Value> val = std::get<std::vector<Value> >(args[0].data);
+	std::vector<Value> result;
+	int begin = (int) args[1].as_number(), end = (int) args[2].as_number(), step = 1;
+	if (end < begin) step = -1;
+	if (args.size() >= 4) {
+		step = (int) args[3].as_number();
+	}
+	for (int i = begin; i != end; i += step) {
+		int it = (i >= 0) ? i : (int(val.size()) + i);
+		if (it < 0 || it >= val.size()) {
+			break;
+		}
+		result.push_back(val[it]);
+	}
+	return Value(result);
+}
+
+// 排序给定的列表，第二个参数表示比较器
+Value _sort(const std::vector<Value>& args) {
+	check_cpp_function_argv_x(args, 1, 2);
+	if (!args[0].is_array()) {
+		L_ERR("sort() requires a list");
+		return LAMINA_NULL;
+	}
+	std::vector<Value> val = std::get<std::vector<Value> >(args[0].data);
+	for (auto &i : val) {
+		if (!i.is_comparable()) {
+			L_ERR("Array has uncomparable object");
+			return args[0];	// A failure, not an error.
+		}
+	}
+	std::function<bool(const Value &a, const Value &b)> comparer;
+	if (args.size() >= 2) {
+		if (!args[1].is_lambda()) {
+			L_ERR("Comparer must be a lambda/function");
+			return LAMINA_NULL;
+		}
+		const auto func = std::get<std::shared_ptr<LambdaDeclExpr>>(args[1].data);
+		comparer = [&func](const Value &a, const Value &b) -> bool {
+			return Interpreter::call_function(func.get(), {a, b}).as_bool();
+		};
+	} else {
+		comparer = [](const Value &a, const Value &b) -> bool {
+			return a < b;
+		};
+	}
+	sort(val.begin(), val.end(), comparer);
+	return Value(val);
+}
\ No newline at end of file
diff --git a/extensions/standard/standard.hpp b/extensions/standard/standard.hpp
index 69188c3..a30f14a 100644
--- a/extensions/standard/standard.hpp
+++ b/extensions/standard/standard.hpp
@@ -150,6 +150,15 @@ Value map(const std::vector<Value>& args);
 // 替换内容：需3个参数（原字符串/容器、目标值、替换值），替换所有匹配的目标值并返回新结果
 Value replace(const std::vector<Value>& args);
 
+// 拼接给定的所有列表
+Value concat(const std::vector<Value>& args);
+
+// 切片，可以为 [a:b] 或 [a:b:c]
+Value slice(const std::vector<Value>& args);
+
+// 排序给定的列表，第二个参数表示比较器
+Value _sort(const std::vector<Value>& args);
+
 // 变量表
 Value vars(const std::vector<Value>& args);
 
@@ -298,6 +307,10 @@ inline std::unordered_map<std::string, Value> register_builtins =
         LAMINA_FUNC("find", find),
         LAMINA_FUNC("map", map),
         LAMINA_FUNC("replace", replace),
+		
+		LAMINA_FUNC("concat", concat),
+		LAMINA_FUNC("slice", slice),
+		LAMINA_FUNC("sort", _sort),
 
         // CAS数学模块：封装符号计算相关的解析、化简、求导等功能
         LAMINA_MODULE("cas", LAMINA_VERSION, {
diff --git a/interpreter/eval.cpp b/interpreter/eval.cpp
index 1cc6d0b..1095575 100644
--- a/interpreter/eval.cpp
+++ b/interpreter/eval.cpp
@@ -74,7 +74,7 @@ Value HANDLE_BINARYEXPR_ADD(Value* l, Value* r) {
         return Value(l->to_string() + r->to_string());
     } else if (ltype & VALUE_IS_ARRAY && rtype & VALUE_IS_ARRAY) {
         // Vector addition
-        return l->vector_add(r);
+        return l->vector_add(*r);
         // 只要有一方是 Irrational 或 Symbolic，优先生成符号表达式
     } else if (((ltype & VALUE_IS_IRRATIONAL) || (ltype & VALUE_IS_SYMBOLIC) || (rtype & VALUE_IS_IRRATIONAL) || (rtype & VALUE_IS_SYMBOLIC)) && (ltype & VALUE_IS_NUMERIC) && (rtype & VALUE_IS_NUMERIC)) {
         std::shared_ptr<SymbolicExpr> leftExpr = GET_SYMBOLICEXPR(l, ltype);
@@ -111,6 +111,7 @@ Value HANDLE_BINARYEXPR_ADD(Value* l, Value* r) {
 Value HANDLE_BINARYEXPR_STR_ADD_STR(Value* l, Value* r) {
     std::string ls = l->to_string();
     std::string rs = r->to_string();
+	/*
     try {
         // Try to parse both strings as CAS expressions and combine them symbolically
         LaminaCAS::Parser pl(ls);
@@ -257,6 +258,8 @@ Value HANDLE_BINARYEXPR_STR_ADD_STR(Value* l, Value* r) {
     } catch (...) {
         // parsing failed for one or both strings; fall back to normal concatenation
     }
+	*/
+	return Value(ls + rs);
 }
 
 Value Interpreter::eval_LiteralExpr(const LiteralExpr* node) {
@@ -337,11 +340,13 @@ Value Interpreter::eval_CallExpr(const CallExpr* call) {
             return {};
         }
         // User function
-        return Interpreter::call_function(func.get(), args, self);
+        return Interpreter::call_function(func.get(), args, self, left.in_module ? Value(left.in_module) : LAMINA_NULL);
     }
 
     if (std::holds_alternative<std::shared_ptr<LmCppFunction>>(left.data)) {
         push_frame("<cpp function>", " ");
+		push_scope();
+		set_module_as(left.in_module ? Value(left.in_module) : LAMINA_NULL);
 
         Value result;
         std::shared_ptr<LmCppFunction> func;
@@ -350,9 +355,11 @@ Value Interpreter::eval_CallExpr(const CallExpr* call) {
             result = func->function(args);
         } catch (...) {
             pop_frame();
+			pop_scope();
             throw;
         }
         pop_frame();
+		pop_scope();
         return result;
     }
 
@@ -360,7 +367,7 @@ Value Interpreter::eval_CallExpr(const CallExpr* call) {
     return {};
 }
 
-Value Interpreter::call_function(const LambdaDeclExpr* func, const std::vector<Value>& args, Value self) {
+Value Interpreter::call_function(const LambdaDeclExpr* func, const std::vector<Value>& args, Value self, Value module) {
     if (func == nullptr) {
         std::cerr << "Error: Function at '" << func << "' is null" << std::endl;
         return Value("<func error>");
@@ -369,6 +376,7 @@ Value Interpreter::call_function(const LambdaDeclExpr* func, const std::vector<V
     Interpreter::push_frame(func->name, "<script>", 0);// Add to call stack
 
     Interpreter::push_scope();// Create scope here
+	Interpreter::set_module_as(module);	// After pushing scope!! If it's null, then there's nothing to consider.
     // Pass arguments
     for (size_t j = 0; j < func->params.size(); ++j) {
         set_variable(func->params[j], args[j]);
@@ -429,6 +437,11 @@ Value Interpreter::eval_BinaryExpr(const BinaryExpr* bin) {
     // Arithmetic operations (require numeric operands or vector operations)
     if (bin->op == "-" || bin->op == "*" || bin->op == "/" ||
         bin->op == "%" || bin->op == "^") {
+		
+		if (l.is_infinity() || r.is_infinity()) {
+			L_ERR("Error: Infinity cannot participate in evaluations");
+		}
+			
         // Special handling for multiplication
         if (bin->op == "*") {
             // Vector and matrix operations
@@ -711,10 +724,44 @@ Value Interpreter::eval_BinaryExpr(const BinaryExpr* bin) {
     // Comparison operators
     if (bin->op == "==" || bin->op == "!=" || bin->op == "<" ||
         bin->op == "<=" || bin->op == ">" || bin->op == ">=") {
+		if (l.is_infinity() && r.is_infinity()) {
+			int lt = std::get<int>(l.data), rt = std::get<int>(r.data);
+			if (bin->op == "==") return lt == rt;
+			else if (bin->op == "!=") return lt != rt;
+			else if (bin->op == "<") return lt < rt;
+			else if (bin->op == "<=") return lt <= rt;
+			else if (bin->op == ">") return lt > rt;
+			else if (bin->op == ">=") return lt >= rt;
+			else return false;
+		}
+		if (l.is_infinity()) {
+			if (bin->op == "==") return false;
+			if (bin->op == "!=") return true;
+			if (bin->op == ">" || bin->op == ">=") return (std::get<int>(l.data) > 0);
+			else return !(std::get<int>(l.data) > 0);
+		}
+		if (r.is_infinity()) {
+			if (bin->op == "==") return false;
+			if (bin->op == "!=") return true;
+			if (bin->op == "<" || bin->op == "<=") return (std::get<int>(r.data) > 0);
+			else return !(std::get<int>(r.data) > 0);
+		}
         // Handle different type combinations
         if (l.is_numeric() && r.is_numeric()) {
             // BigInt 比较优先
-            if (l.is_bigint() || r.is_bigint()) {
+            if (l.is_symbolic() || r.is_symbolic()) {
+				auto ls = l.as_symbolic();
+				auto rs = SymbolicExpr::multiply(SymbolicExpr::number(-1), r.as_symbolic());
+				auto res = SymbolicExpr::add(ls, rs)->simplify();
+				double rd = res->to_double();
+
+				if (bin->op == "==") return Value(rd == 0);
+                if (bin->op == "!=") return Value(rd != 0);
+                if (bin->op == "<") return Value(rd < 0);
+                if (bin->op == "<=") return Value(rd <= 0);
+                if (bin->op == ">") return Value(rd > 0);
+                if (bin->op == ">=") return Value(rd >= 0);
+			} else if (l.is_bigint() || r.is_bigint()) {
                 ::BigInt lb = l.is_bigint() ? std::get<::BigInt>(l.data) : ::BigInt(l.as_number());
                 ::BigInt rb = r.is_bigint() ? std::get<::BigInt>(r.data) : ::BigInt(r.as_number());
 
@@ -760,7 +807,24 @@ Value Interpreter::eval_BinaryExpr(const BinaryExpr* bin) {
                     if (bin->op == ">") return Value(!result_less && ls != rs);
                     if (bin->op == ">=") return Value(!result_less);
                 }
-            } else {
+            } else if (l.is_rational() || r.is_rational()) {
+				const auto& ld = l.as_rational();
+				const auto& rd = r.as_rational();
+				if (bin->op == "==") return Value(ld == rd);
+                if (bin->op == "!=") return Value(ld != rd);
+                if (bin->op == "<") return Value(ld < rd);
+                if (bin->op == "<=") return Value(ld <= rd);
+                if (bin->op == ">") return Value(ld > rd);
+                if (bin->op == ">=") return Value(ld >= rd);
+			} else if ((l.is_array() || l.is_matrix()) && (r.is_array() || r.is_matrix())) {
+				// Implemented in value.hpp
+				bool judge = (l == r);
+				if (bin->op == "==") return Value(judge); 
+				if (bin->op == "!=") return Value(!judge);
+
+				L_ERR("Cannot compare array or matrix with operator '" + bin->op + "'");
+				return Value();
+			} else {
                 double ld = l.as_number();
                 double rd = r.as_number();
 
@@ -805,12 +869,22 @@ Value Interpreter::eval_BinaryExpr(const BinaryExpr* bin) {
         }
     }
 
+	if (bin->op == "and" || bin->op == "or") {
+		bool lb = l.as_bool(), rb = r.as_bool();
+		if (bin->op == "and") return lb and rb;
+		else if (bin->op == "or") return lb or rb;
+	}
+
     L_ERR("Unknown binary operator '" + bin->op + "'");
     return {};
 }
 
 Value Interpreter::eval_UnaryExpr(const UnaryExpr* unary) {
     Value v = eval(unary->operand.get());
+	
+	if (unary->op == "not") {
+		return Value(!v.as_bool());
+	}
 
     if (unary->op == "-") {
         if (v.type != Value::Type::Int && v.type != Value::Type::BigInt && v.type != Value::Type::Float && v.type != Value::Type::Rational) {
diff --git a/interpreter/interpreter.cpp b/interpreter/interpreter.cpp
index 9855741..ca91e3c 100644
--- a/interpreter/interpreter.cpp
+++ b/interpreter/interpreter.cpp
@@ -17,7 +17,8 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <ranges>
+// I think it's 100% meaningless to use ranges simply for a vector-reversing.
+// Why not use iterator/index directly?
 #include <sstream>
 #ifdef _WIN32
 #include <direct.h>
@@ -42,6 +43,7 @@ std::vector<std::unique_ptr<ASTNode>> Interpreter::repl_asts{};
 std::vector<StackFrame> Interpreter::call_stack{};
 std::unordered_map<std::string, Value> Interpreter::builtins = register_builtins;
 std::vector<std::unordered_map<std::string, Value>> Interpreter::variable_stack{{}};
+std::vector<Value> Interpreter::module_stack{{}};
 
 Value new_lm_struct(const std::vector<std::pair<std::string, Value>>& vec);
 
@@ -55,18 +57,36 @@ Interpreter::~Interpreter() {
 // Scope stack operations
 void Interpreter::push_scope() {
     variable_stack.emplace_back();
+	module_stack.emplace_back();
 }
 
 void Interpreter::save_repl_ast(std::unique_ptr<ASTNode> ast) {
     repl_asts.push_back(std::move(ast));
 }
 
+void Interpreter::set_module_as(const Value& mod) {
+	if (module_stack.size()) {
+		module_stack.back() = mod;
+	}
+}
+
 void Interpreter::pop_scope() {
     if (variable_stack.size() > 1) variable_stack.pop_back();
+	if (module_stack.size() > 1) module_stack.pop_back();
 }
 
 Value Interpreter::get_variable(const std::string& name) {
-    for (const auto & it : std::ranges::reverse_view(variable_stack)) {
+    if (module_stack.size() != variable_stack.size()) {
+		std::cerr << "[Interpreter] <Warning> Module stack length " << module_stack.size() << " doesn't match " << variable_stack.size() << "\n";
+	}
+	for (int i = variable_stack.size() - 1; i >= 0; i--) {
+		if (module_stack[i].type == Value::Type::lmModule) {
+			// Attempt to get variable in the module, through:
+			auto& mg = std::get<std::shared_ptr<LmModule>>(module_stack[i].data);
+			if (mg->sub_item.count(name)) return mg->sub_item[name];
+			break;			// In current module only, make isolation
+		}
+		const auto &it = variable_stack[i];
         auto found = it.find(name);
         if (found != it.end()) return found->second;
     }
@@ -83,6 +103,13 @@ Value Interpreter::get_variable(const std::string& name) {
 }
 
 void Interpreter::set_variable(const std::string& name, const Value& val) {
+	if (!module_stack.empty()) {
+		if (!module_stack.back().is_null()) {
+			auto& mg = std::get<std::shared_ptr<LmModule>>(module_stack.back().data);
+			mg->sub_item[name] = val;
+			return;
+		}
+	}
     if (!variable_stack.empty()) {
         (*variable_stack.rbegin())[name] = val;
     }
@@ -95,6 +122,9 @@ void Interpreter::set_global_variable(const std::string& name, const Value& val)
 }
 
 Value Interpreter::execute(const std::unique_ptr<Statement>& node) {
+	
+	//std::cerr << "[Debug output] call of execute in interpreter!\n";
+	
     if (!node) {
         return LAMINA_NULL;
     }
@@ -549,7 +579,7 @@ bool Interpreter::load_module(const std::string& module_path) {
     if (asts.empty()) {
         // print_traceback("<stdin>", lineno);
         // return 1;
-        std::cout << "[Nothing to execute]" << std::endl;
+        std::cout << "Warning: Loading empty module. Nothing to execute!" << std::endl;
         return false;
     }
 
@@ -561,7 +591,7 @@ bool Interpreter::load_module(const std::string& module_path) {
         try {
             execute(stmt);
         } catch (const std::exception& e) {
-            std::cerr << "Error when import other file: " << e.what() << std::endl;
+            std::cerr << "Error when importing other file: " << e.what() << std::endl;
         } catch (...) { // 捕获非标准异常
             std::cerr << "Error: Unknown exception occurred while loading module" << std::endl;
             if (!call_stack.empty()) pop_frame();
@@ -578,33 +608,40 @@ bool Interpreter::load_module(const std::string& module_path) {
         namespace fs = std::filesystem;
         const fs::path path(module_path);
         module_name = path.stem().string();
-        std::cout << "[Debug] Path: " << module_path << " → module: " << module_name << std::endl;
+        //std::cerr << "[Debug] Path: " << module_path << " → module: " << module_name << std::endl;
     }
 
-    std::cout << "\nProgram execution completed." << std::endl;
-    set_variable(module_name,
-        Value(
-            std::make_shared<LmModule>(
+	auto cur_module = std::make_shared<LmModule>(
                 module_name,
                 parser->get_module_version(),
-                module_var_table
-               )
-            )
-    );
+                std::unordered_map<std::string, Value>()
+               );
+	for (auto &i : module_var_table) {
+		i.second.in_module = cur_module;
+	}
+	cur_module->sub_item = module_var_table;
+
+    //std::cerr << "\nModule Loader: Program execution completed." << std::endl;
+    set_variable(module_name, Value(cur_module));
     return true;
 }
 
 bool Interpreter::load_cpp_module(const std::string& module_path) {
-    const auto& module = load_cppmodule(module_path);
+	auto module = load_cppmodule(module_path);	// May result in some problems?
     namespace fs = std::filesystem;
     const fs::path path(module_path);
     std::string module_name = path.stem().string();
-    std::cout << "[Debug] Path: " << module_path << " → module: " << module_name << std::endl;
-    
-    for (const auto& [key, value] : module) {
+    std::cout << "[Debug] Importing Path: " << module_path << " → module: " << module_name << std::endl;
+    std::shared_ptr<LmModule> cur_module = std::make_shared<LmModule>(
+                module_name,
+                "0.0.0",
+                std::unordered_map<std::string, Value>()
+               );
+    for (auto& [key, value] : module) {
         if (key == "lamina_init_module") {
             [[maybe_unused]] auto _ = std::get<std::shared_ptr<LmCppFunction>>(value.data)->function({}); // 初始化函数
         }
+		value.in_module = cur_module;
         std::cerr << "Debug: checking c++ function " << key << std::endl;
     }
     
@@ -618,15 +655,10 @@ bool Interpreter::load_cpp_module(const std::string& module_path) {
     }
 
     const auto version = parse_properties(properties_file_path).at("version");
-    set_variable(module_name,
-        Value(
-            std::make_shared<LmModule>(
-                module_name,
-                version.empty() ? version : "0.0.0" ,
-                module
-               )
-            )
-    );
+	cur_module->sub_item = module;
+	if (!version.empty()) cur_module->id = version;
+	
+    set_variable(module_name, Value(cur_module));
     return true;
 }
 
diff --git a/interpreter/interpreter.hpp b/interpreter/interpreter.hpp
index 526404f..b432f74 100644
--- a/interpreter/interpreter.hpp
+++ b/interpreter/interpreter.hpp
@@ -85,7 +85,7 @@ class LAMINA_API Interpreter {
     static Value eval_UnaryExpr(const UnaryExpr* unary);
     static Value eval_BinaryExpr(const BinaryExpr* bin);
     static Value eval_CallExpr(const CallExpr* call);
-    static Value call_function(const LambdaDeclExpr* func, const std::vector<Value>& args, Value self=LAMINA_NULL) ;
+    static Value call_function(const LambdaDeclExpr* func, const std::vector<Value>& args, Value self=LAMINA_NULL, Value module=LAMINA_NULL);
 
     // Print all variables in current scope
     static void print_variables();
@@ -118,6 +118,9 @@ class LAMINA_API Interpreter {
 
     // Variable scope stack, top is the current scope
     static std::vector<std::unordered_map<std::string, Value>> variable_stack;
+	static std::vector<Value> module_stack;
+
+	static void set_module_as(const Value& mod);
 
 private:
     // Store REPL ASTs to keep function pointers valid in interactive mode
diff --git a/interpreter/lamina_api/lamina.hpp b/interpreter/lamina_api/lamina.hpp
index 034fece..4bde418 100644
--- a/interpreter/lamina_api/lamina.hpp
+++ b/interpreter/lamina_api/lamina.hpp
@@ -82,7 +82,15 @@ inline void L_ERR(const std::string& str) {
 
 inline bool check_cpp_function_argv(const std::vector<Value>& argv, const size_t argc) {
     if (argv.size() != argc) {
-        const std::string msg = "function need " + std::to_string(argc) + ", but got " + std::to_string(argv.size());
+		const std::string msg = "function need " + std::to_string(argc) + " argument(s), but got " + std::to_string(argv.size());
+        throw StdLibException(msg);
+    }
+    return false;
+}
+
+inline bool check_cpp_function_argv_x(const std::vector<Value>& argv, const size_t min_argc, const size_t max_argc) {
+    if (argv.size() < min_argc || argv.size() > max_argc) {
+        const std::string msg = "function need " + std::to_string(min_argc) + " to " + std::to_string(max_argc) + "argument(s), but got " + std::to_string(argv.size());
         throw StdLibException(msg);
     }
     return false;
@@ -94,7 +102,7 @@ inline bool check_cpp_function_argv(
 ) {
 
     if (argv.size() != except_type_vec.size()) {
-        const std::string msg = "function need " + std::to_string(except_type_vec.size()) + ", but got " + std::to_string(argv.size());
+        const std::string msg = "function need " + std::to_string(except_type_vec.size()) + " arguments, but got " + std::to_string(argv.size());
         throw StdLibException(msg);
         return false;
     }
@@ -102,7 +110,7 @@ inline bool check_cpp_function_argv(
     size_t cnt = 0;
     for (const auto& arg: argv) {
         if (arg.type != except_type_vec[cnt]) {
-            const std::string msg =  "callee use illegal type";
+            const std::string msg =  "callee used illegal type";
             throw StdLibException(msg);
             return false;
         }
diff --git a/interpreter/lamina_api/value.hpp b/interpreter/lamina_api/value.hpp
index bb24768..232dd28 100644
--- a/interpreter/lamina_api/value.hpp
+++ b/interpreter/lamina_api/value.hpp
@@ -70,6 +70,7 @@ class LAMINA_API Value final {
 		std::shared_ptr<LambdaDeclExpr>>;
 
     DataType data;
+	std::shared_ptr<LmModule> in_module = nullptr;
 
     ~Value() = default;
 
@@ -146,6 +147,16 @@ class LAMINA_API Value final {
     bool is_lmModule() const { return type == Type::lmModule; }
     bool is_lmCppFunction() const { return type == Type::lmCppFunction; }
     bool is_numeric() const { return type == Type::Int || type == Type::Float || type == Type::BigInt || type == Type::Rational || type == Type::Irrational || type == Type::Symbolic; }
+	bool as_number_compatible() const {
+		if (type == Type::Infinity)  return true;
+        if (type == Type::Int)  return true;
+        if (type == Type::Float)  return true;
+        if (type == Type::BigInt)  return true;
+        if (type == Type::Rational) return true;
+        if (type == Type::Irrational)  return true;
+        if (type == Type::Symbolic) return true;
+		return false;
+	}
     // Get numeric value as double
     double as_number() const {
 		if (type == Type::Infinity) return (1.0 * std::get<int>(data) / 0.0);
@@ -324,13 +335,69 @@ class LAMINA_API Value final {
                 return "<unknown>";
         }
     }
+	
+	bool is_comparable() const {
+		if (as_number_compatible() || is_array() || is_string())
+			return true;
+		return false;
+	}
 
     // ToDo: for set type
     bool operator<(const Value& other) const {
-        return false;
+        if (as_number_compatible() && other.as_number_compatible())
+			return as_number() < other.as_number();
+		if (is_string() || other.is_string()) {
+			return to_string() < other.to_string();
+		}
+		if (this->type != other.type)
+			return false;	// Can't compare
+		if (is_array()) {
+			// The other is array as well
+			auto ma = std::get<std::vector<Value> >(data);
+			auto oa = std::get<std::vector<Value> >(other.data);
+			for (size_t i = 0; i < ma.size() && i < oa.size(); i++) {
+				if (ma[i] < oa[i]) return true;
+			}
+			if (ma.size() < oa.size()) return true;
+			return false;
+		}
+		return false;	// Can't compare for other types
     }
     bool operator==(const Value& other) const {
-        return false;
+        if (this->type != other.type)
+			return false;	// Can't compare
+		// TODO: Increase its precision
+        if (as_number_compatible() && other.as_number_compatible())
+			return as_number() == other.as_number();
+		if (is_string()) {
+			return to_string() == other.to_string();
+		}
+		if (is_array()) {
+			// The other is array as well
+			auto ma = std::get<std::vector<Value> >(data);
+			auto oa = std::get<std::vector<Value> >(other.data);
+			if (ma.size() != oa.size()) return false;
+			for (size_t i = 0; i < ma.size() && i < oa.size(); i++) {
+				if (!(ma[i] == oa[i])) return false;
+			}
+			return true;
+		}
+		if (is_matrix()) {
+			auto ma = std::get<std::vector<std::vector<Value> > >(data);
+			auto oa = std::get<std::vector<std::vector<Value> > >(other.data);
+			if (ma.size() != oa.size()) return false;
+			for (size_t i = 0; i < ma.size() && i < oa.size(); i++) {
+				if (ma[i].size() != oa[i].size()) return false;
+				for (size_t j = 0; j < ma[i].size() && j < oa[i].size(); j++) {
+					if (!(ma[i][j] == oa[i][j])) return false;
+				}
+			}
+			return true;
+		}
+		if (is_lstruct()) {
+			// TODO: Implement this
+		}
+		return false;	// TODO: For other types, consider all of them independent so far
     }
 
     // Vector operations
diff --git a/interpreter/lexer.cpp b/interpreter/lexer.cpp
index 23758f9..f2869a7 100644
--- a/interpreter/lexer.cpp
+++ b/interpreter/lexer.cpp
@@ -30,6 +30,9 @@ void registerKeywords() {
     keywords["null"] = LexerTokenType::Null;
     keywords["do"] = LexerTokenType::Lambda;
     keywords["loop"] = LexerTokenType::Loop;
+	keywords["and"] = LexerTokenType::LogicalAnd;
+	keywords["or"] = LexerTokenType::LogicalOr;
+	keywords["not"] = LexerTokenType::LogicalNot;
     keywords_registered = true;
 }
 
diff --git a/interpreter/lexer.hpp b/interpreter/lexer.hpp
index 1c10e09..961e4bc 100644
--- a/interpreter/lexer.hpp
+++ b/interpreter/lexer.hpp
@@ -67,6 +67,9 @@ enum class LexerTokenType {
     Pipe,        // |
     FatArrow,    // =>
     ThinArrow,   // ->
+	LogicalAnd,
+	LogicalOr,
+	LogicalNot,
     EndOfFile,
     EndOfLine,
     Unknown
diff --git a/interpreter/parse_expr.cpp b/interpreter/parse_expr.cpp
index 6a22681..78015e4 100644
--- a/interpreter/parse_expr.cpp
+++ b/interpreter/parse_expr.cpp
@@ -3,8 +3,17 @@
 #include "parser.hpp"
 
 std::unique_ptr<Expression> Parser::parse_expression() {
-    // ToDo: add op support 'and' 'or' 'not in' 'in'
-    return parse_comparison();
+    // ToDo: add op support 'not in' 'in'
+	auto node = parse_comparison();
+	while (curr_token().type == LexerTokenType::LogicalAnd
+		or curr_token().type == LexerTokenType::LogicalOr
+	) {
+		auto tok = curr_token();
+        auto op = skip_token().text;
+        auto right = parse_comparison();
+        node = std::make_unique<BinaryExpr>(std::move(op), std::move(node), std::move(right));
+	}
+    return node;
 }
 
 std::unique_ptr<Expression> Parser::parse_comparison() {
@@ -66,13 +75,16 @@ std::unique_ptr<Expression> Parser::parse_power() {
 }
 
 std::unique_ptr<Expression> Parser::parse_unary() {
-    // ToDo: add op support 'not'
     if (curr_token().type == LexerTokenType::Minus) {
         auto tok = curr_token();
         skip_token();
         auto operand = parse_unary();
         return std::make_unique<UnaryExpr>("-", std::move(operand));
-    }
+    } else if (curr_token().type == LexerTokenType::LogicalNot) {
+		skip_token("not");
+		auto operand = parse_factor();
+		return std::make_unique<UnaryExpr>("not", std::move(operand));
+	}
     return parse_factor();
 }
 
diff --git a/interpreter/parse_factor.cpp b/interpreter/parse_factor.cpp
index aaf2fbd..587199b 100644
--- a/interpreter/parse_factor.cpp
+++ b/interpreter/parse_factor.cpp
@@ -33,6 +33,7 @@ std::unique_ptr<Expression> Parser::parse_a_token() {
 
         skip_token("{");
         auto stmt = parse_block(true);
+		//std::cerr << "[Debug output] lambda processor end!\n";
         skip_token("}");
         return std::make_unique<LambdaDeclExpr>("<lambda>", std::move(params),std::move(stmt));
     }
@@ -56,14 +57,21 @@ std::unique_ptr<Expression> Parser::parse_a_token() {
     if (tok.type == LexerTokenType::LBrace) {
         std::vector<std::pair<std::string, std::unique_ptr<Expression>>> init_vec{};
         while (curr_token().type != LexerTokenType::RBrace) {
-            auto key = skip_token().text;
+            //auto key = skip_token().text;
+			std::string key = "";
+			do {
+				key = skip_token().text;
+			} while (key == "\n" || key == "\t" || key == " " || key == ";" || key == "\r" || key == "");
+			if (key == "}") {
+				break;
+			}
             skip_token("=");
             auto val = parse_expression();
             if (curr_token().type == LexerTokenType::Comma) skip_token(",");
             if (curr_token().type == LexerTokenType::Semicolon) skip_token(";");
             init_vec.emplace_back(std::move(key), std::move(val));
         }
-        skip_token("}");
+        if (curr_token().type == LexerTokenType::RBrace) skip_token("}");
         return std::make_unique<LambdaStructDeclExpr>(std::move(init_vec));
     }
     if (tok.type == LexerTokenType::LBracket) {
diff --git a/interpreter/parse_stmt.cpp b/interpreter/parse_stmt.cpp
index 0df5d3c..d0c979f 100644
--- a/interpreter/parse_stmt.cpp
+++ b/interpreter/parse_stmt.cpp
@@ -1,10 +1,25 @@
 #include "lexer.hpp"
 #include "parser.hpp"
 std::unique_ptr<BlockStmt> Parser::parse_block(bool is_global) {
+	// Is this boolean parameter really useful???
     std::vector<std::unique_ptr<Statement>> stmts;
     while (curr_token().type != LexerTokenType::RBrace) {
-        stmts.emplace_back(parse_stmt());
-        if (curr_token().type == LexerTokenType::Semicolon) skip_token(";");
+		//std::cerr << "[Debug output] parse through blocks! Current: " << curr_token().text << std::endl;
+		auto pres = parse_stmt();
+		if (pres)
+			stmts.push_back(move(pres));
+		//else std::cerr << "[Debug output] resolved empty statement!\n";
+		//std::cerr << "[Debug output] statement parser end\n";
+		// I think we should sooner or later make this an independent function:
+		bool flag = false;
+		do {
+			flag = false;
+			while (curr_token().type == LexerTokenType::Semicolon
+					or curr_token().type == LexerTokenType::EndOfLine) {
+				skip_token();	// Maybe shall be forced?
+				flag = true;
+			}
+		} while (flag);
     }
     return std::make_unique<BlockStmt>(std::move(stmts));
 }
diff --git a/interpreter/parser.cpp b/interpreter/parser.cpp
index 292d9ea..7268b47 100644
--- a/interpreter/parser.cpp
+++ b/interpreter/parser.cpp
@@ -18,8 +18,7 @@ Token Parser::skip_token(const std::string& want_skip) {
     if (curr_tok_idx_ < tokens_.size()) {
         auto& tok = tokens_[curr_tok_idx_];
         if (!want_skip.empty() and tok.text != want_skip) {
-            std::cerr << ConClr::RED
-            << "There should be '" << want_skip << "' , but you given '"
+			std::cerr << ConClr::RED << "Error: At line " << tok.line << " column " << tok.column << ": There should be '" << want_skip << "' , but you given '"
             << tok.text << "'" << ConClr::RESET << std::endl;
             throw StdLibException("");
         }
@@ -55,9 +54,8 @@ void Parser::skip_end_of_ln() {
 
     // 仅在“非文件结尾”时报错
     if (curr_token().type != LexerTokenType::EndOfFile) {
-        std::cerr << ConClr::RED 
-                  << "Statement must end with ';' or newline, got '" << curr_token().text << "'" 
-                  << ConClr::RESET << std::endl;
+		auto& tok = tokens_[curr_tok_idx_];
+        std::cerr << ConClr::RED << "Error: At line " << tok.line << ": " << "End of line must be ';', got '" << tok.text << "'" << ConClr::RESET << std::endl;
         throw StdLibException("invalid statement terminator");
     }
 }
@@ -65,7 +63,7 @@ void Parser::skip_end_of_ln() {
 void Parser::must_token(const std::string& text, const std::string& waring) const {
     if (const auto tok = this->curr_token();
         tok.text != text) {
-        std::cerr << ConClr::RED << "The word'" << tok.text << "' cause error that : \n"
+         std::cerr << ConClr::RED << "Error: At line " << tok.line << " column " << tok.column << ": The word'" << tok.text << "' cause error that : \n"
                   << waring
                   << ConClr::RESET << std::endl;
     }
@@ -78,14 +76,24 @@ std::vector<std::unique_ptr<Statement>> Parser::parse_program() {
             s != nullptr
         ) {
             stmts.push_back(std::move(s));
+			//std::cerr << "[Debug output] end of program statement processor!\n";
         }
     }
+	//std::cerr << "[Debug output] finished parser.\n";
     return stmts;
 }
 
 std::unique_ptr<Statement> Parser::parse_stmt() {
+	// A little bit weird, but ok for current use
+	while (curr_tok_idx_ < tokens_.size() && curr_token().type == LexerTokenType::EndOfLine) {
+        skip_token(); 
+    }
     auto tok = curr_token();
-
+	if (tok.type == LexerTokenType::EndOfFile || tok.type == LexerTokenType::Semicolon) {
+		//std::cerr << "[Debug output] !!! Semicolon/EOF appeared at the beginning of statement parser !!!\n";
+		return nullptr;
+	}
+	//std::cerr << "[Debug output] in token: " << tok.text << std::endl;
     if (tok.type == LexerTokenType::If) {
         skip_token("if");
         return parse_if();
@@ -135,7 +143,7 @@ std::unique_ptr<Statement> Parser::parse_stmt() {
         skip_token("loop");
         // Disallow empty immediate '{' to remove infinite-loop syntax
         if (curr_token().text == "{") {
-            std::cerr << "SyntaxError: infinite 'loop { }' is not supported; use 'loop <count-expression> { ... }'" << std::endl;
+            std::cerr << "SyntaxError: infinite 'loop { }' is no longer supported; use 'loop <count-expression> { ... }'" << std::endl;
             throw StdLibException("invalid loop syntax: infinite loop removed");
         }
         auto count_expr = parse_expression();