Inheritance was invented as a performance hack(catern.com)

  function f() {
    function g() {
      return 1
    }
    return { g }
  }

  function f1(f) {
    function g() {
      return f.g() + 1
    }
    return { g } 
  }

  f1(f())

    class Stack(...) extends Stack {
       def push(element) returns IO[nothing] = ...
       
       def pop() returns IO[element] = ...
    }

    class CountingStack(underlyingStack) extends Stack {
       override def push(element) returns IO[nothing] =
           underlyingStack.push(element).andThen(nothing => count += 1; return nothing)
       
       override def pop() returns element =
           underlyingStack.pop(element).andThen(element => count += 1; return element)
    }

    fn id<T>(t: T) { }

    fn main() {
       id(String::from("foo"));
       id(1_usize);
    }

  struct Vehicle
  {
    speed: f32,
    type: VehicleType
  }

  enum VehicleType
  {
    Car(...),
    Bicycle(...)
  }

  struct Vehicle
  {
    data: VehicleData
    type: Box<dyn SpecificVehicle>
  }

  struct VehicleData
  {
    speed: f32,
  }

  trait SpecificVehicle
  {
    fn quack(&self, data: &VehicleData);
  }

  impl SpecificVehicle for Car {...}
  impl SpecificVehicle for Bicycle {...}