Overload example

scopegraphs/examples/overload/ast.rs

@@ -0,0 +1,37 @@
+#[derive(Debug, Clone)]
+pub struct Program {
+    pub functions: Vec<Function>,
+    pub main: Expr,
+}
+
+#[derive(Debug, Clone)]
+pub struct Function {
+    pub name: String,
+    pub args: Vec<Arg>,
+    pub return_type: Option<Type>,
+    pub body: Expr,
+}
+
+#[derive(Debug, Clone)]
+pub struct Arg {
+    pub name: String,
+    pub type_ann: Option<Type>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Type {
+    IntT,
+    BoolT,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Expr {
+    IntLit(u64),
+    BoolLit(bool),
+    Ident(String),
+    Plus(Box<Expr>, Box<Expr>),
+    Lt(Box<Expr>, Box<Expr>),
+    IfThenElse(Box<Expr>, Box<Expr>, Box<Expr>),
+    FunCall(String, Vec<Expr>),
+    Ascribe(Box<Expr>, Type),
+}

scopegraphs/examples/overload/main.rs

@@ -1,3 +1,49 @@
+#![allow(unused)]
+
+use crate::ast::*;
+use crate::parse::parse;
+
+mod ast;
+mod parse;
+mod type_check;
+mod union_find;
+
 pub fn main() {
-    println!("Hello from overload example!")
+    let program = "
+        fun tt() = true;
+        fun not(b) = if b { false } else { true };
+        fun and(b1: bool, b2): bool = 
+            if b1 {
+                if b2 {
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            };
+
+        $ and(not(false), tt())
+    ";
+
+    let result = parse(program);
+
+    println!("{:?}", result);
+
+    assert!(result.is_ok())
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PartialType {
+    // Types are not recursive, so no need to have separate constructors for each variant
+    Type(Type),
+    Variable(TypeVar),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TypeVar(usize);
+
+pub struct FunType {
+    return_type: PartialType,
+    arg_types: Vec<(String, PartialType)>,
 }