// adds a and b, but also 4 for some reason
fn add(a: i64, b: i64): i64 {
    let foo = 4; // because I feel like it
    let test_float: f64 = {
      10.2
    };
    test_float = 5.0;
    a + b + foo
}

fn subtract(a: i64, b: i64): i64 {
    a - b
}

fn return_type_test(a: f64): f64 {
    return a * 2.0;
}

fn i_hate_this(a: f64): f64 {
    return {
        return {
            return a;
        };
    };
}

fn unit_function() {
  let a: i64 = 4;
}

fn returns_user(): User {
    return User{
        id: 4,
    };
}

fn get_user_id(): i64 {
    let user = returns_user();
    user.id = 5;
    return user.id;
}

fn use_method(user: User): i64 {
    return user.get_id();
}

type User struct {
    id: i64,
}

type Generic[T] struct {
    value: T,
}

impl User {
    fn new(id: i64): Self {
        return Self{
            id: id,
        };
    }

    fn get_id(self: Self): i64 {
        return self.id;
    }
}

fn if_expression(): i64 {
  if (true) {
    return 6;
  } else {
    return 9;
  }
}

fn main(): i64 {
    let a = User{id: 4};
    let b = a.instance_method();
    b
}

type TestTrait trait {
    fn class_method(id: i64): Self;
    fn instance_method(self: Self): i64;
    fn default_impl(self: Self): i64;
}

impl TestTrait for User {
    fn class_method(id: i64): Self {
        return Self{id: id,};
    }
    fn instance_method(self: Self): i64 {
        return self.get_id();
    }
    fn default_impl(self: Self): i64 {
        return self.instance_method();
    }
}