class Rectangle {
    int width, height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    public int Width() {
        return width;
    }
    public int Height() {
        return height;
    }
}

class Square extends Rectangle {
    public Square(int side) {
        super(side, side);
    }
}

interface IFigure
{}

interface IWidth
{
 public int Width
 { get };
}

interface IHeight
{
 public int Height
 { get };
}

interface IRectangle : IWidth, IHeight
{
}

class Rectangle : IRectangle
{
 public int Width
 { get { return _width; } };
 public int Height
 { get { return _height; } };
 
 private int _width;
 private int _height;
}

interface ISide
{
 public int Side
 { get };

 public int Angle
 { get };
}

interface IRhombus : ISide
{}

class Rhombus : IRhombus
{
 public int Side
 { get { return _side; } };

 public int Angle
 { get { return _angle; } };

 int _side;
 int _angle;
}

interface ISquare : IRectangle , IRhombus

class Square : ISquare
{
 public int Width
 { get { return _width; } };
 public int Height
 { get { return _height; } };
 
 private int _width;
 private int _height;

 public int Side
 { get { return _side; } };

 public int Angle
 { get { return _angle; } };

 int _side;
 int _angle;

 // код для сохранения _width == _height == _side && _angle == 90  :maniac: 
}

[Contract(ISquare, Width == Height)]
interface IRectangle
{...}

class Rectangle : IRectangle
{...}

[Contract(ISquare, Angle == 90)]
interface IRhombus
{...}

class Rhombus : IRhombus
{...}

void f(ISquare) {...}

Rectangle r1 = new Rectange(1,1); // r1 : ISquare
Rectangle r2 = new Rectange(1,2); // r2 : IRectangle

f(r1); // OK
f(r2); // Ошибка ??

interface IRectangle
{
    int Width {get;}
    int Height {get;}
}

interface ISquare : IRectangle
{
    int Size {get;}
}

class Rectangle : IRectangle
{
    int _width;
    int _height;
    ...
}

class Square : ISquare
{
    int _size;
    ...
}

__>interface ISquare : IRectangle , IRhombus

r = Rectangle(100, 100);

ME>r = Rectangle(100, 100);

Many binary operations of interest in both algebra and formal logic are commutative or associative. Many also have identity elements and inverse elements. Typical examples of binary operations are the addition (+) and multiplication (*) of numbers and matrices as well as composition of functions on a single set.

Examples of operations that are not commutative are subtraction (-), division (/), exponentiation(^), and super-exponentiation(@).

(http://en.wikipedia.org/wiki/Binary_operation)

public interface Figure {
    T IsA<T>() where T: Figure;
}

public interface Rectangle : Figure {
    int Width { get; }
    int Height { get; }
}

public interface Square : Figure {
    int Size { get; }
}

public class Figure4 : Figure {
    public T IsA<T> where T: Figure {
        if(T is Square 
             && Size0==Size1 && Size0==Size2 && Size0==Size3 
             && Angle0==90) // в градусах например
            return new SqareImpl(this.Size0);
            
        ...
        return null;
    }
}

(/) :: (R\{0}) x (R\{0}) -> (R\{0})

либо
(/) :: R x (R\{0}) -> R
либо
(/) :: (R_+) x (R_+) -> (R_+)
где R_+ ::= R + {Infinity, -Infinity, NaN}

r = new Rectangle(100, 100);

void foo (Square const & sq) { ... }

void test
{
  Rectangle rect(2, 2);
  foo (rect); // Почему нет?
}

... in mathematics a circle is a kind
of an ellipse, but in most programs a circle should not be derived from an ellipse or an ellipse
derived from a circle. The oftenheard
arguments ‘‘because that’s the way it is in mathematics’’
and ‘‘because the representation of a circle is a subset of that of an ellipse’’ are not conclusive and
most often wrong. This is because for most programs, the key property of a circle is that it has a
center and a fixed distance to its perimeter. All behavior of a circle (all operations) must maintain
this property (invariant; §24.3.7.1).

Square specializes Rectangle
{
  invariant { base.a == base.b; }
  ...
}

Rectangle rect (2, 3);
Rectangle rect2 = SomeOperations (rect);
if (rect2 is Square) // проверка всего-лишь инварианта rect2.a == rect2.b
{
  ...
}

VE>Square specializes Rectangle
VE>{
VE>  invariant { base.a == base.b; }
VE>  ...
VE>}

VE>Rectangle rect (2, 3);
VE>Rectangle rect2 = SomeOperations (rect);
VE>if (rect2 is Square) // проверка всего-лишь инварианта rect2.a == rect2.b
VE>{
VE>  ...
VE>}
VE>

Button b = new ButtonWithText("bla-bla");

Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

T>Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

class Square{
public:
  explicit Square(int len = 1):m_Len(len){};
  virtual ~Square() {};
  virtual GetSquare() const {return m_Len*m_Len;}
  virtual GetPerimeter() const {return m_Len*4;}
protected:
  int m_Len;
}

class Rectangle: public Square{
public:
  explicit Rectangle(int len = 1, int width = 1):m_Len(len), m_Width(width){};
  virtual ~Rectangle() {};
  virtual GetSquare() const {return m_Len*m_Width;}
  virtual GetPerimeter() const {return m_Len*2 + m_Width*2;}
protected:
  int m_Width;
}

Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

Равенство сторон("Квадрат") = true
Равенство сторон("Прямоугольник") = false

Let Равенство сторон(x) be a property provable about objects x of type "Квадрат". Then Равенство сторон(y) should be true for objects y of type "Прямоугольник" where "Прямоугольник" is a subtype of "Квадрат".

_>А что такое "Просто Button"?

1.3.3 dynamic type [defns.dynamic.type]
the type of the most derived object (1.8) to which the lvalue denoted by an lvalue expression refers. [Example:
if a pointer (8.3.1) p whose static type is “pointer to class B” is pointing to an object of class D, derived
from B (clause 10), the dynamic type of the expression *p is “D.” References (8.3.2) are treated similarly. ]
The dynamic type of an rvalue expression is its static type.

Matrix<4, 3> m1;
Matrix<3, 4> m2;
double D = ((SquareMatrix<4>)(m1 * m2)).Determinant();

Matrix<4, 3> m1;
Matrix<3, 4> m2;
double D = Determinant(m1 * m2);

1.2.0 alpha rev. 655

class Rectangle{
public:
  explicit Rectangle(double x, double y):m_x(x), m_y(y){};
  virtual double GetSquare() const{ return m_x*m_y;}; // Пока всё хорошо
  virtual double GetPerimeter() const{ return 2.0*(m_x+m_y);}; // Тоже ok.
  // Получаем копию масштабированную в n раз только по x
  virtual const Rectangle GetCopyX(double n){
    return Rectangle(m_x*n, m_y);
  } // Ага! доигрались.
protected:
  // Раздельная модификация (и вообще модификация) сторон невозможна.
  const double m_x;
  const double m_y;
};

// Теперь квадрат. У него переопределяется только конструктор
class Square: public Rectangle{
public:
  explicit Square(double x): ::Rectangle(x, x){};
  // Здесь придётся идти на кривые уловки, например делать
  // private: const Rectangle GetCopyX(double n){}; // чтобы её не дай Б-же не вызвали
};

    . . .
    final int width, height;
    . . .

class Rectangle;
class Square : Rectange;

Square *sq = new Square(5);
assert(sq.GetWidth()*4 == sq.GetPerimeter());
Rectange *rect = sq;
assert((rect.GetWidth()+rect.GetHeight())*2 == rect.GetPerimeter());

class Square;
class Rectangle : Square;

Rectangle *rect = new Rectangle(3,4);
Square *sq = rect;
assert(sq.GetWidth()*4 == sq.GetPerimeter());//Бабах!

Rectangle *rect = new Rectangle(3,4);
Square *sq = rect;
assert(sq.GetWidth()*4 == sq.GetPerimeter());//Бабах!

    class Rectangle
    {
        public Rectangle(int width, int height)
        {
            this.width = width;
            this.height = height;
        }
        public Rectangle(int squareSide)
            : this(squareSide, squareSide)
        {
        }

        public bool IsSquare
        {
            get { return this.width == this.height; }
        }

        private int width;
        public int Width
        {
            get { return this.width; }
            set { this.width = value; }
        }

        private int height;
        public int Height
        {
            get { return this.height; }
            set { this.height = value; }
        }
    }

class Suqare extends Rectangle where (width == height)
{
...
}