Other language features

Question

For these language features I should probably start a JSR, however, I want the opinion of the public for it.
1) Language construct "alias"
Many classes with different names do things which are nearly 100% the same. For example the Point and Dimension classes within the AWT framework. They collect the same data, only the name is different and the method names are different.
It should be possible to make a simple base implementation of this and derive aliasses from this. This could look like:
public class SomeClass { ... }which in another file could be aliased like:
public class AnotherClass alias SomeClass;From the point of view of the point and dimension classes, the method names are also different, this could be solved by the following:
public class SomeClass {
    public void someMethod() {}
}which could be aliased like:
public class AnotherClass alias SomeClass {
    anotherMethod alias someMethod // Keeping overloads correct
}Note that an alias should be upcasted automatically but should manually be downcasted. With the addition of generics, it should give more room to decent notation.
2) Language construct "range"
Enumerations are very handy when dealing with logical named ranges such as dates and flags. However, if the range is numeric it is not possible to use a normal enum. There for my suggestion is the addition of the keyword range (a symboloc variant seems possible to me).
A n example of constructing a range could be:
public int range(20,30) somerange;Just as in the "alias" construct ranges should be upcasted automatically but should manually be downcasted.
These two constructs are used in languages like C++, ADA and others, so it is not something which isn't used.

Answer 1

This is going to be a large post, so hang tight!
As the first reply talks about interfaces I give you partially credit, but that is not the reason why I suggested the "alias" key word.
Suppose we have a highly simplified version of the Point and Dimension classes which these days look the following:
// Point class
public class Point {
    private int x = 0;
    private int y = 0;
    public void setLeft(int left) { x = left; }
    public void setTop(int top) { y = top; }
    public int getLeft() { return x; }
    public int getTop() { return y; }
// Dimension class
public class Dimension {
    private int x = 0;
    private int y = 0;
    public void setRight(int right) { x = right; }
    public void setBottom(int bottom) { y = bottom; }
    public int getRight() { return x; }
    public int getBottom() { return y; }
}As you will notice, the classes core code is exactly the same. However, the methods in Both classes will fill memory. This could be eliminated when using the "alias" keyword. The following code represents my idea behind this.
// Class representing the calculation logic of both Point as Dimension
// It seems feasible to have a construct that the class should always have to be
// used with an alias type, therefor, I typed "abstract alias".
abstract alias class XY {
    private int x = 0;
    private int y = 0;
    public void setX(int x) { this.x = x; }
    public void setY(int y) { this.y = y; }
    public int getX() { return x; }
    public int getY() { return y; }
// Point class, alias for  XY
public class Point alias XY {
    setLeft alias setX;
    setTop alias setY;
    getLeft alias getX;
    getTop alias getY;
// Dimension class
public class Dimension alias XY {
    setRight alias setX;
    setBottom alias setY;
    getRight alias getX;
    getBottom alias getY;
}I hope this will clear things up a little bit. These are only changes to the name of the method and the class, not to the implementation of it. They should become double references to the same methods.
The second feature I suggested, the range feature would indeed be an infrigement to the compatibility to older classes which may use the range as a regular name. Here I will give a try again.
int (20...30) limited;In this case a new primitive is created called limited, which is almost exactly the same as the int promitive, but can only store 20 through 30 to it. The following code demonstrates the idea behind it.
int (20...30) limited;
// use limited
public void mainMethod() {
    limited foo = 25; // Compiles OK
    foo = 35; // Fails to compile
    int bar = foo; // Compiles OK
    foo = bar; // Fails to compile
    foo = (foo)bar; // Compiles ok, would throw a runtime exception when bar < 20 or > 30
}I hope this demonstrates the usage.
The suggestion about the "with" keyword is not really clear to me. Is it used to use bean-like methods as properties? If it is so, then you should know that this is already made possible using meta-attributes. If it is used to get rid of the notation of the variable, I would doubt if it improves readability, but hey, that is my opinion.
Greetings,
Sjoerd