interface Thingable {
  method : virtual : public : Thing() ~ String;
}

class Delegator {
  @delegate : Thingable;

  New() {
  }

  method : public : SetDelegate(delegate : Thingable) ~ Nil {
    @delegate := delegate;
  }

  method : public : Operation() ~ String {
    if(@delegate = Nil) {
      return "default implementation";
    }
    else {
      return @delegate->Thing();
    };
  }
}

class Delegate implements Thingable {
  New() {
  }

  method : public : Thing() ~ String {
    return "delegate implementation";
  }
}

class Example {
  function : Main(args : String[]) ~ Nil {
    # Without a delegate:
    a := Delegator->New();
    Runtime->Assert(a->Operation()->Equals("default implementation"));

    # With a delegate:
    d := Delegate->New();
    a->SetDelegate(d);
    Runtime->Assert(a->Operation()->Equals("delegate implementation"));

    # Same as the above, but with an anonymous class:
    a->SetDelegate(Base->New() implements Thingable {
      method : public : Thing() ~ String {
        return "anonymous delegate implementation";
      }
    });

    Runtime->Assert(a->Operation()->Equals("anonymous delegate implementation"));
  }
}