Semantics

Semantic rules:

• Class called Driver should not have any formals because it is the entry point

// Good
class Driver() { }

// Bad 
class Driver(foo: String) { }

• No shadowing of variables whatsoever

// Good
class Foo(bar: String) {
   { var baz: Int = 3 }
}

// Bad
class Foo(foo: String) {
   { var foo: Int = 3 }
}

• Names in typed arms should be unique

// Good
class Foo() {
  match "" with {
      case x: String => "hello world!",
      case y: String => "hello world!",
      case null => null
  }
}

// Bad
class Foo() {
  match "" with {
      case x: String => "hello world!",
      case x: String => "hello world!",
      case null => null
  }
}

• Upon overriding a function, the formal types should be superset equals of parent level formal types

// Good
class Foo() extends IO() { 
 def bar(f: Foo) : String = null
}

class Driver() extends Foo() {
 override def bar(f: Driver) : String = null
}

// Bad
class Foo() extends IO() { 
 def bar(f: Foo) : String = null
}

class Driver() extends Foo() {
 override def bar(f: IO) : String = null
}

• Match arms should narrow down that type and not broaden it

// Good
class Foo() extends IO {
  match this with {
      case x: Foo => x,
      case y: IO => y,
      case null => null
  }
}

// Bad
class Foo() extends IO {
  match this with {
      case x: IO => x,
      case y: Foo => y,
      case null => null
  }
}

• No duplicate class name

// Good
class Foo() { }
class Bar() { }

// Bad
class Foo() { }
class Foo() { }

• Any is the root type
• If a class does not extend any other class, then it is implicitly extending Any

// Equivalent
class Foo()
class Foo() extends Any()