'This' type

AUTHOR: Lasu aka Marek Kozieł http://lasu2string.blogspot.com/

OVERVIEW

FEATURE SUMMARY:
This type add ability to project valid interfaces(classes) for further extending/implementing. 'This' means current interface/class type or something implementing/extending it.

MAJOR ADVANTAGE:

• Support of interface projecting at interface level.
• More readable code structure (interfaces/methods).
• Making refactor more enjoyable (much easier).
• Discarding request of replacing 'void' with 'this'.
• Splitting interfaces to sub-interfaces can become pleasant.
• Down casting working properly.
• Decreasing number of method signatures in classes/interfaces.

MAJOR DISADVANTAGE:

• Class 'This' may already exist somewhere in code(?)
• As so far, it's not been thought over know if there is point of using it for input parameters.
• 'This.class' might be a problem for generics, but generally everything depends on how 'This' is interpreted(personally, I think that it should be generic with arguments)(this.getClass()).

ALTERNATIVES:
Rewriting each method's signature on every class / interface.

EXAMPLES

  public static interface IB implements Iterable<This> {
  }

  public static interface IC implements IB {
  }

Would mean(which is impossible now time):

  public static interface IC implementsIB, Iterable<IC> {
  }

public static interface IA {
    This write(String s);
  }

  public static interface IB extends IA {
    This write(double value);
  }
  
  public abstract static class CC implements IB {
    This write(int value){
      ...
      return this;
    }
  }
  
  public static class CD extends CC {
    @Override
    public This write(double value) {
      ...
      return this;
    }
    @Override
    public This write(String s) {
      ...
      return this;
    }
  }

  public static void main(String[] args) {
    CD object = new CD();
    object.write("Some").write(3).write(3.11);
  }

Nowdays, the same code would look as:

public static interface IA {
    IA write(String s);
  }

  public static interface IB extends IA {
    IB write(double value);
    @Override
    IB write(String s);
  }
  
  public abstract static class CC implements IB {
    CC write(int value){
      ...
      return this;
    }
    
    @Override
    public abstract CC write(double value);
    
    @Override
    public abstract CC write(String s);
  }
  
  public static class CD extends CC {
    @Override
    public CD write(double value) {
      ...
      return this;
    }
    @Override
    public CD write(String s) {
      ...
      return this;
    }
    @Override
    CD write(int value){
      ...
      return this;
    }
  }

DETAILS:

SPECIFICATION:
(I did not have time to analyze this completely.)

COMPILATION:
With 'This' type is valid:

• this
• null
• ? extends This

'This' should be considered to be able to appear in:

• return type(yes).
• input type(yes/no?).
• method body(yes?).
• As generic parameter(yes/only if they appear as return types?).

List<This extends Container<This>> would mean This but not less than Container

This could be reduced to last superclass

COMPATIBILITY

Only programs where are class/interface named 'This' used can be problem.

REFERENCES

Notice that considered document does not contain complete analyze of those solutions and can have some lacks. So if you have some questions/advices that it does not fully fit with Project Coin, post it on my blog to discuss:
http://lasu2string.blogspot.com/2009/03/this-type.html

:

Instrukcje

Może to nie jest jasne jednak o ile klasy podlegają dziedziczeniu to już typy nie. Efektem tego jest dość paranoidalna sytuacja w której z jednej strony sugeruje się stosowanie interfejsów a z drugiej uniemożliwia się tworzenie ciągów wywołań.

Dość średnim sposobem rozwiązania tego problemu była propozycja wprowadzenia automatycznej konwersji void na this. Jednak są ludzie którzy świadomie stosują void np. żeby później zdefiniować pożądany zwracany typ ( bugi wynikajace ze zmian murowane ).

Przegląd

Główne zalety / korzyści:

• Uproszczenie struktury kodu.
• Uproszczenie projektowania złożonych interfejsów.

Najistotniejsze wady:

• Komplikacja struktury kodu.
• Trzeba się zastanowić czy This ma sens jako parametr wejściowy.
• Istnieją klasy o nazwie 'This'.

Inne rozwiązania:

• Przepisać każdą metodę jeszcze raz w każdej klasie/interfejsie ze zmienionym typem zwracanym.
• Zwracać void i zmuszać programistów do bardziej 'jawnych' wywołań.

Podsumowanie:

Przykłady:

public static interface IA {
    This write(String s);
  }

  public static interface IB extends IA {
    This write(double value);
  }
  
  public abstract static class CC implements IB {
    This write(int value){
      ...
      return this;
    }
  }
  
  public static class CD extends CC {
    @Override
    public This write(double value) {
      ...
      return this;
    }
    @Override
    public This write(String s) {
      ...
      return this;
    }
  }

  public static void main(String[] args) {
    CD object = new CD();
    object.write("Some").write(3).write(3.11);
  }

Aby osiągnąć podobny efekt dziś musieli byśmy napisać:

public static interface IA {
    IA write(String s);
  }

  public static interface IB extends IA {
    IB write(double value);
    @Override
    IB write(String s);
  }
  
  public abstract static class CC implements IB {
    CC write(int value){
      ...
      return this;
    }
    
    @Override
    public abstract CC write(double value);
    
    @Override
    public abstract CC write(String s);
  }
  
  public static class CD extends CC {
    @Override
    public CD write(double value) {
      ...
      return this;
    }
    @Override
    public CD write(String s) {
      ...
      return this;
    }
    @Override
    CD write(int value){
      ...
      return this;
    }
  }

Detale rozwiązania:

Co jest typu This?

• zmienne typu This
• this
• null
• zmienne typu ? extends This

Kompatybilność:

Wsteczna:
Pełna.

W przód:
Brak.