const -> let

include/build_visitor.hpp

@@ -91,6 +91,8 @@ private:
   void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
+  void Visit(AndExpression* node) override;
+  void Visit(OrExpression* node) override;
   void Visit(ArrayExpression* node) override;
 
   void Visit(LoopControlExpression& node) override; // enum

include/builtin_functions.hpp

@@ -22,4 +22,12 @@ inline T Read() {
   return value;
 }
 
+template<typename T>
+inline void Error(const T& value) { // only for strings ??
+  std::cout << "\x1b[1;33mError:\x1b[0m ";
+  std::cout << value;
+  std::cout << '\n';
+  exit(1);
+}
+
 } // namespace info

include/execute_visitor.hpp

@@ -100,6 +100,8 @@ private:
   void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
+  void Visit(AndExpression* node) override;
+  void Visit(OrExpression* node) override;
   void Visit(ArrayExpression* node) override;
 
   void Visit(LoopControlExpression& node) override; // enum

include/find_symbols_visitor.hpp

@@ -76,6 +76,8 @@ private:
   // // void Visit(TypeConstructorParameter* node) override;
   // // void Visit(TypeConstructor* node) override;
   // // void Visit(LambdaFunction* node) override;
+  // // void Visit(AndExpression* node) override;
+  // // void Visit(OrExpression* node) override;
   // // void Visit(ArrayExpression* node) override;
 
   // // void Visit(LoopControlExpression& node) override; // enum

include/interpreter_tree.hpp

@@ -131,7 +131,6 @@ using SubExpressionToken = std::variant<
   std::unique_ptr<ReferenceExpression>>;
 //
 struct FunctionCallExpression;
-struct ArrayExpression;
 using SubExpression = std::variant< // BiaryOperatorExpression is FunctionCallExpression
   std::unique_ptr<FunctionCallExpression>,
   std::unique_ptr<SubExpressionToken>>;
@@ -149,11 +148,17 @@ using PrefixedExpression = std::variant<
 //
 struct LambdaFunction;
 struct TypeConstructor;
+struct AndExpression;
+struct OrExpression;
+struct ArrayExpression;
 using Expression = std::variant<
   std::unique_ptr<LambdaFunction>,
   std::unique_ptr<TypeConstructor>,
   std::unique_ptr<PrefixedExpression>,
-  std::unique_ptr<SubExpression>>;
+  std::unique_ptr<SubExpression>,
+  std::unique_ptr<AndExpression>,
+  std::unique_ptr<OrExpression>,
+  std::unique_ptr<ArrayExpression>>;
 //
 struct TupleExpression;
 struct VariantExpression;
@@ -161,7 +166,6 @@ using SuperExpression = std::variant<
   std::unique_ptr<FlowControl>,
   std::unique_ptr<TupleExpression>,
   std::unique_ptr<VariantExpression>,
-  std::unique_ptr<ArrayExpression>,
   std::unique_ptr<Expression>>;
 //
 
@@ -181,6 +185,8 @@ struct ReturnExpression;
 struct TypeConstructorParameter;
 struct TypeConstructor;
 struct LambdaFunction;
+struct AndExpression;
+struct OrExpression;
 struct ArrayExpression;
 
 // Name
@@ -525,7 +531,7 @@ struct FunctionCallExpression {
                              std::unique_ptr<WrappedTypeExpression>>> prefix;
   NameOrOperatorIdentifier name;
   std::vector<std::unique_ptr<TypeExpression>> parameters;
-  std::vector<SubExpression> arguments;
+  std::vector<std::pair<std::optional<NameIdentifier>, SubExpression>> arguments;
 
   std::optional<size_t> precedence; // for operators
   bool is_binary_operator_expression = false; // for operators
@@ -587,6 +593,18 @@ struct LambdaFunction {
   utils::IdType return_type_graph_id_ = 0;
 };
 
+struct AndExpression {
+  BaseNode base;
+
+  std::vector<SubExpression> expressions;
+};
+
+struct OrExpression {
+  BaseNode base;
+
+  std::vector<SubExpression> expressions;
+};
+
 struct ArrayExpression {
   BaseNode base;
 
@@ -632,7 +650,7 @@ struct Name {
 struct FunctionType {
   BaseNode base;
 
-  std::vector<std::unique_ptr<ExtendedScopedAnyType>> types;
+  std::vector<std::pair<std::optional<NameIdentifier>, std::unique_ptr<ExtendedScopedAnyType>>> types;
 };
 
 struct TupleType {

include/link_symbols_visitor.hpp

@@ -85,6 +85,8 @@ private:
   // // void Visit(TypeConstructorParameter* node) override;
   // // void Visit(TypeConstructor* node) override;
   // // void Visit(LambdaFunction* node) override;
+  // // void Visit(AndExpression* node) override;
+  // // void Visit(OrExpression* node) override;
   // // void Visit(ArrayExpression* node) override;
 
   // // void Visit(LoopControlExpression& node) override; // enum

include/parse_token_types.hpp

@@ -77,6 +77,8 @@ const std::string ReturnExpression = "return_expression";
 const std::string TypeConstructorParameter = "type_constructor_parameter";
 const std::string TypeConstructor = "type_constructor";
 const std::string LambdaFunction = "lambda_function";
+const std::string AndExpression = "and_expression";
+const std::string OrExpression = "or_expression";
 const std::string ArrayExpression = "array_expression";
 const std::string LoopControlExpression = "loop_control_expression";
 

include/print_visitor.hpp

@@ -74,6 +74,8 @@ private:
   void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
+  void Visit(AndExpression* node) override;
+  void Visit(OrExpression* node) override;
   void Visit(ArrayExpression* node) override;
 
   void Visit(LoopControlExpression& node) override; // enum

include/type_check_visitor.hpp

@@ -95,6 +95,8 @@ private:
   void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
+  void Visit(AndExpression* node) override;
+  void Visit(OrExpression* node) override;
   void Visit(ArrayExpression* node) override;
 
   void Visit(LoopControlExpression& node) override; // enum

include/typed_print_visitor.hpp

@@ -76,6 +76,8 @@ private:
   void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
+  void Visit(AndExpression* node) override;
+  void Visit(OrExpression* node) override;
   void Visit(ArrayExpression* node) override;
 
   void Visit(LoopControlExpression& node) override; // enum

include/utils.hpp

@@ -27,7 +27,7 @@ enum class ClassModifier { Struct = 0, Class = 1 };
 enum class AssignmentModifier { Assign = 0, Move = 1 };
 enum class AliasModifier { Alias = 0, Type = 1, Let = 2 };
 enum class AbstractTypeModifier { Basic = 0, Abstract = 1 };
-enum class PartitionModifier { Exec = 0, Test = 1 };
+enum class PartitionModifier { Exec = 0, Test = 1, Example = 2 };
 
 enum class ValueType { Const = 0, Var = 1, Tmp = 2 };
 

include/visitor.hpp

@@ -88,6 +88,8 @@ protected:
   virtual void Visit(TypeConstructorParameter* node);
   virtual void Visit(TypeConstructor* node);
   virtual void Visit(LambdaFunction* node);
+  virtual void Visit(AndExpression* node);
+  virtual void Visit(OrExpression* node);
   virtual void Visit(ArrayExpression* node);
 
   virtual void Visit(LoopControlExpression& node); // enum