implemented new type systems

Author: tomoyanonymous

src/basic/abstractions.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "basic/helper_functions.hpp"
+namespace mimium {
+template <template <class> class C>
+struct MakeRecursive {
+  using type = C<Box<MakeRecursive>>;
+};
+
+template <template <class...> class Category, class T, int ID = 0>
+struct CategoryWrapped {
+  using type = Category<T>;
+  type v;
+};
+
+template <class T>
+using IdentCategory = T;
+
+template <class T>
+using List = std::list<T>;
+
+template <class T>
+using Set = std::unordered_set<T>;
+template <class FROM, class TO>
+using Map = std::unordered_map<FROM, TO>;
+
+template <class R, class... ArgTypes>
+using Fn = std::function<R(ArgTypes...)>;
+
+template <class T, template <class...> class C, template <class...> class... Cs>
+struct Nested {
+  using type = C<Nested<T, Cs...>>;
+};
+}  // namespace mimium

src/basic/ast_new.hpp

@@ -1,26 +1,15 @@
 #pragma once
 
 #include <list>
+#include "abstractions.hpp"
 #include "type.hpp"
 
 namespace mimium {
 
-template <template <class> class C>
-struct MakeRecursive {
-  using asts = C<Box<MakeRecursive>>;
-  using type = typename asts::Expr;
-};
-
 template <class EXPR>
 struct Ast {
   template <template <class...> class Category, class T, int ID = 0>
-  struct Aggregate {
-    Category<T> v;
-    using type = Category<T>;
-  };
-
-  template <class T>
-  using IdentCategory = T;
+  using Aggregate = CategoryWrapped<Category, T, ID>;
 
   template <class T, int ID = 0>
   using Primitive = Aggregate<IdentCategory, T, ID>;
@@ -31,9 +20,6 @@ struct Ast {
   using StringLit = Primitive<std::string>;
   using Symbol = Primitive<std::string, 1>;
 
-  template <class T>
-  using List = std::list<T>;
-
   using TupleLit = Aggregate<List, EXPR>;
   using ArrayLit = Aggregate<List, EXPR, 1>;
   struct StructKey {
@@ -90,16 +76,16 @@ using ExprBase = std::variant<FloatLit,
   // the Ast struct has to declare Expr type to use in MakeRecursive Container.
   using Expr = ExprBase<App, Let>;
 };
-using ExprPrim = MakeRecursive<Ast>;
+using ExprPrim = MakeRecursive<Ast>::type;
 
-ExprPrim::type e{ExprPrim::asts::FloatLit{0.0}};
-auto& test = std::get<ExprPrim::asts::FloatLit>(e);
+ExprPrim::Expr e{ExprPrim::FloatLit{0.0}};
+auto& test = std::get<ExprPrim::FloatLit>(e);
 
 // HIGH-LEVEL AST including Syntactic Sugar
 template <class EXPR>
 struct Hast {
   template <template <class...> class T, class U, int ID = 0>
-  using Aggregate = ExprPrim::asts::Aggregate<T, U, ID>;
+  using Aggregate = ExprPrim::Aggregate<T, U, ID>;
 
   struct CurryPlaceHolder {};
   using CurryArg = std::variant<EXPR, CurryPlaceHolder>;
@@ -131,18 +117,18 @@ struct Hast {
   };
   using Assignment = AssignmentProto<EXPR>;
   template <class T>
-  using LCategory = ExprPrim::asts::LambdaCategory<T>;
+  using LCategory = ExprPrim::LambdaCategory<T>;
   using DefFnRvalue = typename Aggregate<LCategory, EXPR>::type;
   using DefFn = AssignmentProto<DefFnRvalue>;
 
-  using Statements = std::variant<Assignment, DefFn, ExprPrim::asts::App>;
+  using Statements = std::variant<Assignment, DefFn, ExprPrim::App>;
 
   //   using ExtFun;TODO
   using Block = Aggregate<std::list, Statements>;
-  using Expr = ExprPrim::asts::ExprBase<Infix, Schedule, EnvVar, App, Block>;
+  using Expr = ExprPrim::ExprBase<Infix, Schedule, EnvVar, App, Block>;
 };
 
-using HExpr = MakeRecursive<Hast>;
+using HExpr = MakeRecursive<Hast>::type;
 
 struct TypeAlias;  // type name = hoge
 

src/basic/type_new.hpp

@@ -0,0 +1,95 @@
+#pragma once
+#include "abstractions.hpp"
+
+namespace mimium {
+
+template <class Value>
+struct Type {
+  struct Unit {};
+  struct Bool {};
+  struct Int {};
+  struct Float {};
+  struct String {};
+  template <template <class...> class C, int ID = 0>
+  using Aggregate = CategoryWrapped<C, Value, ID>;
+  // T1 * T2 * T3 ...
+  using Tuple = Aggregate<List>;
+  // T1 | T2 | T3...
+  using Variant = Aggregate<List, 1>;
+  // T1 -> T2 -> T3...
+  using Function = Aggregate<List, 2>;
+
+  template <class Identifier>
+  struct RecordCategory {
+    Identifier key;
+    Value v;
+  };
+  using Record = CategoryWrapped<List, RecordCategory<std::string>>;
+
+  // Identified type
+  template <class T>
+  struct IdentifiedCategory {
+    T id;
+    Value v;
+  };
+  using Identified = typename CategoryWrapped<IdentifiedCategory, int>::type;
+
+  template <class... T>
+  using TypeBase = std::variant<Unit, Bool, Int, Float, String, Tuple, Variant, Function, Record,
+                                Identified, T...>;
+
+  using Intermediate = typename CategoryWrapped<IdentifiedCategory, int, 1>::type;
+  using HType = TypeBase<>;
+
+  using IType = TypeBase<Intermediate>;
+
+  struct LType {};
+};
+
+using types = MakeRecursive<Type>::type;
+
+template <class ID, class Value>
+struct Alias {
+  ID name;
+  Value v;
+};
+
+struct TypeResolver {
+  using HType = types::HType;
+
+  // TypeIdの集合と束縛のリスト
+  template <class T>
+  using Binding = std::pair<T, T>;
+  using IType = types::IType;
+  using Constraints = Set<Binding<IType>>;
+  using map = Map<IType, HType>;
+};
+
+// 変数と型の写像がスコープごとに
+template <class Env>
+struct Environment {
+  template <class T, class Identifier>
+  struct Value {
+    Map<Identifier, T> map;
+    std::optional<Env> e;
+  };
+};
+template <class T>
+using TypeEnv = MakeRecursive<Environment>::type::Value<T, std::string>;
+
+template <class AST>
+struct TypeInferer {
+  // ASTを入れると中間変数を含む型環境が帰ってくる
+  using Pass1 = TypeEnv<types::IType>(AST);
+  //中間変数を含む型環境を受け取り、変数同士の制約を作る
+  using Pass2 = TypeResolver::Constraints(std::result_of_t<Pass1>);
+  //変数の制約を受け取り、中間変数を含む型集合->中間変数を取り除いた型集合 の写像をつくる
+  using Pass3 = TypeResolver::map(std::result_of_t<Pass2>);
+  //中間変数を含む型環境と、中間変数を含む型集合->中間変数を取り除いた型集合の写像を受け取り、
+  //中間変数を取り除いた型環境を返す
+  using Pass4 = TypeEnv<types::HType>(std::result_of_t<Pass1>, std::result_of_t<Pass3>);
+  //全体としては、ASTを入れると中間変数がない型環境が帰ってくる
+  using type = TypeEnv<types::HType>(AST);
+};
+
+}  // namespace mimium