AD>Расскажите, плиз, только попроще и по русски

FUNCTIONS THAT USE POINTERS OR REFERENCES TO BASE CLASSES MUST BE ABLE TO USE OBJECTS OF DERIVED CLASSES WITHOUT KNOWING IT
Above is a paraphrase of the Liskov Substitution Principle (LSP). Barbara Liskov first
it as follows nearly 8 years ago. What is wanted here is something like the following substitution property: If
for each object o of type S there is an object o of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o is substituted for o then S is a subtype of T.

void DrawShape(const Shape& s)
{
    if (typeid(s) == typeid(Square))
        DrawSquare(static_cast<Square&>(s));
    else if (typeid(s) == typeid(Circle))
        DrawCircle(static_cast<Circle&>(s));
}

VG>void DrawShape(const Shape& s)
VG>{
VG>    if (typeid(s) == typeid(Square))
VG>        DrawSquare(static_cast<Square&>(s));
VG>    else if (typeid(s) == typeid(Circle))
VG>        DrawCircle(static_cast<Circle&>(s));
VG>}
VG>

DrawShape(shape : Shape) : void
{
  | square is Square => DrawSquare(square);
  | circle is Circle => DrawCircle(circle);
    | _                => DoDefaultAction(shape);
}

Subtypes must be substitutable for their base types

VD>Тут уже пробегала цитата про паттерны GoF и динамические языки

AD>Расскажите, плиз, только попроще и по русски

Если подстановка типа A, вместо типа B не приводит к изменению поведения программы P, то тип A, явялется подтипом B.

СГ>вроде аналогичный, а ничего не нарушает

Oberon-2 introduced limited reflection, methods ("type bound procedures"), and single inheritance ("type extension") without interfaces or mixins. Method calls were resolved at run-time, and limited polymorphism was possible by either overloading methods or by explicit typecase ("with" statement).

VG>вместо одного "msg.DoSomething()"

  TYPE
    CursorMessage = ABSTRACT RECORD (RequestMessage)
      x, y: INTEGER
    END;

    DropMsg = RECORD (TransferMessage)
      view: Views.View;
      isSingle: BOOLEAN;
      w, h, rx, ry: INTEGER
    END;

    EditMsg = RECORD (RequestMessage)
      op: INTEGER;
      modifiers: SET;
      char: CHAR;
      view: Views.View;
      w, h: INTEGER;
      isSingle, clipboard: BOOLEAN
    END;

    MarkMsg = RECORD (Views.CtrlMessage)
      show, focus: BOOLEAN
    END;

    Message = Views.CtrlMessage;

    PageMsg = RECORD (Views.CtrlMessage)
      op, pageX, pageY: INTEGER;
      done, eox, eoy: BOOLEAN
    END;

    PollCursorMsg = RECORD (CursorMessage)
      cursor: INTEGER;
      modifiers: SET
    END;

    PollDropMsg = RECORD (TransferMessage)
      mark, show: BOOLEAN;
      type: Stores.TypeName;
      isSingle: BOOLEAN;
      w, h, rx, ry: INTEGER;
      dest: Views.Frame
    END;

    PollFocusMsg = EXTENSIBLE RECORD (Views.CtrlMessage)
      focus: Views.Frame
    END;

    PollOpsMsg = RECORD (Views.CtrlMessage)
      type, pasteType: Stores.TypeName;
      singleton: Views.View;
      selectable: BOOLEAN;
      valid: SET
    END;

    PollSectionMsg = RECORD (Views.CtrlMessage)
      focus, vertical: BOOLEAN;
      wholeSize, partSize, partPos: INTEGER;
      valid, done: BOOLEAN
    END;

    ReplaceViewMsg = RECORD (RequestMessage)
      old, new: Views.View
    END;

    RequestMessage = ABSTRACT RECORD (Views.CtrlMessage)
      requestFocus: BOOLEAN
    END;

    ScrollMsg = RECORD (Views.CtrlMessage)
      focus, vertical: BOOLEAN;
      op, pos: INTEGER;
      done: BOOLEAN
    END;

    SelectMsg = RECORD (Views.CtrlMessage)
      set: BOOLEAN
    END;

    TickMsg = RECORD (Views.CtrlMessage)
      tick: INTEGER
    END;

    TrackMsg = RECORD (CursorMessage)
      modifiers: SET
    END;

    TransferMessage = ABSTRACT RECORD (CursorMessage)
      source: Views.Frame;
      sourceX, sourceY: INTEGER
    END;

    WheelMsg = RECORD (CursorMessage)
      done: BOOLEAN;
      op, nofLines: INTEGER
    END;

TYPE WheelMsg (CursorMessage)
Это сообщение посылается, когда колесо на мыши с колесом поворачивается.

done: BOOLEAN
Если отображение обрабатывает это сообщение, оно должно установить флаг done в TRUE.

op: INTEGER
Показывает, какой тип события колеса мыши произошел. Используются те же константы, что и для прокрутки, но допустимы только следующие из них: incPage, decPage, incLine and decLine.

nofLines: INTEGER nofLines >= 1
Если op или icnLine, или decLine, то nofLines показывает, сколько строк должно быть прокручено. Для incPage и decPage это значение не определено.

System.NullReferenceException: Object reference not set to an instance of an object.
at Rsdn.Janus.TagLineManager.FindAppropriateTagLine(TagLineInfos tagLineInfos, Int32 forumId)
at Rsdn.Janus.DatabaseManager.AddOutboxMessage(MessageInfo mi)
at Rsdn.Janus.MessageForm.SaveMessage(Boolean closeOnSave)
at Rsdn.Janus.MessageForm.WriteMessageHandler()
at Rsdn.Janus.Framework.StripEventDispatcher.DispatchEvent(String eventId)
at Rsdn.Janus.Framework.StripEventDispatcher.ClickHandler(Object sender, EventArgs e)
at System.Windows.Forms.ToolStripItem.RaiseEvent(Object key,

VG>void DrawShape(const Shape& s)
VG>{
VG>    if (typeid(s) == typeid(Square))
VG>        DrawSquare(static_cast<Square&>(s));
VG>    else if (typeid(s) == typeid(Circle))
VG>        DrawCircle(static_cast<Circle&>(s));
VG>}
VG>

void DrawShape(const Shape& s)
{
    if (typeid(s) == typeid(Square))
        DrawSquare(static_cast<Square&>(s));
    else if (typeid(s) == typeid(Circle))
        DrawCircle(static_cast<Circle&>(s));
    else s.Draw();
}

public variant Expr
{
  | Literal { value : double; }
  | Call    { name : string; parms : list[Expr]; }
  | Plus    { expr1 : Expr; expr2 : Expr; }
  | Minus   { expr1 : Expr; expr2 : Expr; }
  | Mul     { expr1 : Expr; expr2 : Expr; }
  | Div     { expr1 : Expr; expr2 : Expr; }
}

public override ToString() : string
{
  match (this)
  {
    | Literal(value)    => value.ToString()
    | Call(name, parms) => $"$name($(parms.Map(_.ToString()).ToString(\", \")))"
    | Plus(e1, e2) with op = "+" | Minus(e1, e2) with op = "-" 
    | Mul(e1, e2)  with op = "*" | Div(e1, e2)   with op = "/" => $"$e1 $op $e2"
  }
}

public Eval() : double
{
  match (this)
  {
    | Literal(value)    => value
    | Call("max", [arg1, arg2]) => Math.Max(arg1.Eval(), arg2.Eval())
    | Call("min", [arg1, arg2]) => Math.Min(arg1.Eval(), arg2.Eval())
    | Call(_, _)                => throw InvalidOperationException(this.ToString());
    | Plus(e1,  e2)             => e1.Eval() + e2.Eval()
    | Minus(e1, e2)             => e1.Eval() - e2.Eval()
    | Mul(e1,   e2)             => e1.Eval() * e2.Eval()
    | Div(e1,   e2)             => e1.Eval() / e2.Eval()
  }
}

using System;
using System.Console;
using Nemerle.Utility;
using Expr;

public variant Expr
{
  | Literal { value : double; }
  | Call    { name : string; parms : list[Expr]; }
  | Plus    { expr1 : Expr; expr2 : Expr; }
  | Minus   { expr1 : Expr; expr2 : Expr; }
  | Mul     { expr1 : Expr; expr2 : Expr; }
  | Div     { expr1 : Expr; expr2 : Expr; }
  
  public override ToString() : string
  {
    match (this)
    {
      | Literal(value)    => value.ToString()
      | Call(name, parms) => $"$name($(parms.Map(_.ToString()).ToString(\", \")))"
      | Plus(e1, e2) with op = "+" | Minus(e1, e2) with op = "-" 
      | Mul(e1, e2)  with op = "*" | Div(e1, e2)   with op = "/" => $"$e1 $op $e2"
    }
  }

  public Eval() : double
  {
    match (this)
    {
      | Literal(value)    => value
      | Call("max", [arg1, arg2]) => Math.Max(arg1.Eval(), arg2.Eval())
      | Call("min", [arg1, arg2]) => Math.Min(arg1.Eval(), arg2.Eval())
      | Call(_, _)                => throw InvalidOperationException(this.ToString());
      | Plus(e1,  e2)             => e1.Eval() + e2.Eval()
      | Minus(e1, e2)             => e1.Eval() - e2.Eval()
      | Mul(e1,   e2)             => e1.Eval() * e2.Eval()
      | Div(e1,   e2)             => e1.Eval() / e2.Eval()
    }
  }
}

module Program
{
  Main() : void
  {
    def expr = Plus(Literal(1.23), Call("max", [Literal(1), Literal(2)]));
    WriteLine($"Expression '$expr' = $(expr.Eval())");
    //_ = ReadLine();
  }
}

using System;
using System.Collections.Generic;
using System.Text;

public interface IExprVisiter
{
    void Visit(Literal expr);
    void Visit(Call expr);
    void Visit(Plus expr);
    void Visit(Minus expr);
    void Visit(Mul expr);
    void Visit(Div expr);
}

public abstract class Expr
{
    public abstract void AceptVisiter(IExprVisiter visiter);

    public override string ToString()
    {
        ToStringExprVisiter visiter = new ToStringExprVisiter();
        AceptVisiter(visiter);
        return visiter.ToString();
    }
}

public class Literal : Expr
{
    public Literal(double value)
    {
        _value = value;
    }

    double _value;

    public double Value
    {
        get { return _value; }
    }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

public class Call : Expr
{
    public Call(string name, params Expr[] parm)
    {
        _name = name;
        _parms = parm;
    }

    string _name;

    public string Name
    {
        get { return _name; }
    }

    Expr[] _parms;

    public Expr[] Parms
    {
        get { return _parms; }
    }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

public abstract class Operator : Expr
{
    public Operator(Expr expr1, Expr expr2)
    {
        _expr1 = expr1;
        _expr2 = expr2;
    }

    Expr _expr1;

    public Expr Expr1
    {
        get { return _expr1; }
        set { _expr1 = value; }
    }

    Expr _expr2;

    public Expr Expr2
    {
        get { return _expr2; }
        set { _expr2 = value; }
    }
}

public class Plus : Operator
{
    public Plus(Expr expr1, Expr expr2) : base(expr1, expr2) { }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

public class Minus : Operator
{
    public Minus(Expr expr1, Expr expr2) : base(expr1, expr2) { }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

public class Mul : Operator
{
    public Mul(Expr expr1, Expr expr2) : base(expr1, expr2) { }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

public class Div : Operator
{
    public Div(Expr expr1, Expr expr2) : base(expr1, expr2) { }

    public override void AceptVisiter(IExprVisiter visiter)
    {
        visiter.Visit(this);
    }
}

class ToStringExprVisiter : IExprVisiter
{
    StringBuilder _bilder = new StringBuilder();

    public override string ToString()
    {
        return _bilder.ToString();
    }

    void PrintList(IList<Expr> lst)
    {
        foreach (Expr var in lst)
        {
            var.AceptVisiter(this);
            _bilder.Append(", ");
        }

        if (lst.Count > 0)
            _bilder.Length -= ", ".Length;
    }

    public void Visit(Literal expr)
    {
        _bilder.Append(expr.Value);
    }

    public void Visit(Call expr)
    {
        _bilder.Append(expr.Name);
        _bilder.Append("(");
        PrintList(expr.Parms);
        _bilder.Append(")");
    }

    void VisitOperator(Operator expr, string kind)
    {
        expr.Expr1.AceptVisiter(this);
        _bilder.Append(kind);
        expr.Expr2.AceptVisiter(this);
    }

    public void Visit(Plus expr)
    {
        VisitOperator(expr, " + ");
    }

    public void Visit(Minus expr)
    {
        VisitOperator(expr, " - ");
    }

    public void Visit(Mul expr)
    {
        VisitOperator(expr, " * ");
    }

    public void Visit(Div expr)
    {
        VisitOperator(expr, " / ");
    }
}

class EvalExprVisiter : IExprVisiter
{
    public double Result;

    public double Eval(Expr expression)
    {
        expression.AceptVisiter(this);
        return Result;
    }

    public void Visit(Literal expr)
    {
        Result = expr.Value;
    }

    public void Visit(Call expr)
    {
        switch (expr.Name)
        {
            case "min":
                if (expr.Parms.Length != 2)
                    throw new InvalidOperationException(expr.ToString());
                Result = Math.Min(Eval(expr.Parms[0]), Eval(expr.Parms[1]));
                return;

            case "max":
                if (expr.Parms.Length != 2)
                    throw new InvalidOperationException(expr.ToString());
                Result = Math.Max(Eval(expr.Parms[0]), Eval(expr.Parms[1]));
                return;

            default: throw new InvalidOperationException(expr.ToString());
        }
    }

    public void Visit(Plus expr)
    {
        Result = Eval(expr.Expr1) + Eval(expr.Expr2);
    }

    public void Visit(Minus expr)
    {
        Result = Eval(expr.Expr1) - Eval(expr.Expr2);
    }

    public void Visit(Mul expr)
    {
        Result = Eval(expr.Expr1) * Eval(expr.Expr2);
    }

    public void Visit(Div expr)
    {
        Result = Eval(expr.Expr1) / Eval(expr.Expr2);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Expr expr = new Plus(new Literal(1.23), new Call("max", new Literal(1), new Literal(2)));
        Console.WriteLine("Expression '{0}' = {1}", expr, new EvalExprVisiter().Eval(expr));
    }
}

public variant Expr
{
  ...
  | Div     { expr1 : Expr; expr2 : Expr; }
  | Mod    { expr1 : Expr; expr2 : Expr; }
  ...

Main.n(18,5,18,10): warning : matching is not exhaustive, example unmatched value: Mod
Main.n(29,5,29,10): warning : matching is not exhaustive, example unmatched value: Mod

VD>public variant Expr
VD>{
VD>  | Literal { value : double; }
VD>  | Call    { name : string; parms : list[Expr]; }
VD>  | Plus    { expr1 : Expr; expr2 : Expr; }
VD>  | Minus   { expr1 : Expr; expr2 : Expr; }
VD>  | Mul     { expr1 : Expr; expr2 : Expr; }
VD>  | Div     { expr1 : Expr; expr2 : Expr; }
  
VD>  public override ToString() : string
VD>  {
VD>    match (this)
VD>    {
VD>      | Literal(value)    => value.ToString()
VD>      | Call(name, parms) => $"$name($(parms.Map(_.ToString()).ToString(\", \")))"
VD>      | Plus(e1, e2) with op = "+" | Minus(e1, e2) with op = "-" 
VD>      | Mul(e1, e2)  with op = "*" | Div(e1, e2)   with op = "/" => $"$e1 $op $e2"
VD>    }
VD>  }
VD>

struct expr
{
    enum type {Literal, Call, Plus, Minus, Mul, Div} t;
    union
    {
        double value;
        struct {const char* name; expr* params[10]; int count;};
        struct {expr *expr1, *expr2;};
    } data;
};

void to_str(const expr* e)
{
    switch (e->t)
    {
    case expr::Literal: cout << e->data.value; break;
    case expr::Call: cout << e->data.name << "("; 
        for (int i = 0; i < e->data.count; ++i)
        {
            to_str(e->data.params[i]);
            cout << "," + !!i;
        }
        cout << ")"; break;
    case expr::Plus: to_str(e->data.expr1); cout << "+"; to_str(e->data.expr2); break;
    case expr::Minus: to_str(e->data.expr1); cout << "-"; to_str(e->data.expr2); break;
    case expr::Mul: to_str(e->data.expr1); cout << "*"; to_str(e->data.expr2); break;
    case expr::Div: to_str(e->data.expr1); cout << "/"; to_str(e->data.expr2); break;
    }
}

R>void to_str(const expr* e)
R>{
R>    switch (e->t)
R>    {
R>    case expr::Literal: cout << e->data.value; break;
R>    case expr::Call: cout << e->data.name << "("; 
R>        for (int i = 0; i < e->data.count; ++i)
R>        {
R>            to_str(e->data.params[i]);
R>            cout << "," + !!i;
R>        }
R>        cout << ")"; break;
R>    case expr::Plus: to_str(e->data.expr1); cout << "+"; to_str(e->data.expr2); break;
R>    case expr::Minus: to_str(e->data.expr1); cout << "-"; to_str(e->data.expr2); break;
R>    case expr::Mul: to_str(e->data.expr1); cout << "*"; to_str(e->data.expr2); break;
R>    case expr::Div: to_str(e->data.expr1); cout << "/"; to_str(e->data.expr2); break;
R>    }
R>}
R>

public override ToString() : string
{
  match (this)
  {
    | Literal(value)    => value.ToString()
    | Call(name, parms) => $"$name($(parms.Map(_.ToString()).ToString(\", \")))"
    | Plus(e1, e2) with op = "+" | Minus(e1, e2) with op = "-" 
    | Mul(e1, e2)  with op = "*" | Div(e1, e2)   with op = "/" => $"$e1 $op $e2"
  }
}

match (this)
{
    ...
    | Call("max", [arg1, arg2]) => Math.Max(arg1.Eval(), arg2.Eval())
    | Call("min", [arg1, arg2]) => Math.Min(arg1.Eval(), arg2.Eval())
    | Call(_, _)                => throw InvalidOperationException(this.ToString());

R>

| Call("max", [arg1, arg2]) => Math.Max(arg1.Eval(), arg2.Eval())
| Call("min", [arg1, arg2]) => Math.Min(arg1.Eval(), arg2.Eval())
| Call(_, _)                => throw InvalidOperationException(this.ToString());

| Call(_, _)                => throw InvalidOperationException(this.ToString());

Index: ncc/generation/ILEmitter.n
===================================================================
--- ncc/generation/ILEmitter.n    (revision 7181)
+++ ncc/generation/ILEmitter.n    (working copy)
@@ -574,6 +574,10 @@
           def emit_branch (expr : TExpr, else_label : Label) {
             Mark (expr.loc);
             match (expr) {
+              | Call (OpCode ("=="), [nested_cond,
+                 Parm where (expr = TExpr.TypeConversion(TExpr.Literal(Literal.Bool(true)), _, _))], _) =>
+                emit_branch(nested_cond.expr, else_label)
+
               | Call (OpCode (opcode), parms, _) =>
                 emit_parms (parms);

IL_000e: blt.s IL_0016
IL_0010: ldc.i4.0 
IL_0011: br IL_0017
IL_0016: ldc.i4.1 
IL_0017: ldc.i4.1 
IL_0018: bne.un IL_0026

IL_000e: bge IL_001c

GetExpr(expression : TExpr) : object
{
| StaticRef(from, mem, _)          =>      // { from : MType.Class; mem : IMember; type_parms : list [TyVar]; }

    if (mem.MemberType != MemberTypes.Constructor && from.tycon.Name == PExprName)
        from
    else
        mem : object

| TypeConversion(_, tt, _)         =>      // { mutable expr : TExpr; target_type : TyVar; kind : ConversionKind; }

    if (tt.IsFixed)
    {
        match (tt.FixedValue)
        {
        | Class(tycon, _) =>

            def dt = tycon.DeclaringType;
            if (dt != null && dt.Name == PExprName) dt else tt : object

        | _ => tt
        }
    }
    else
        tt

| Literal(Enum(value, ty, null))   => 

    def members = ty.GetMembers();
    def field   = members.Find(f =>
    {
        match (f)
        {
        | f is IField when f.IsStatic && f.IsLiteral =>

            match (f.GetValue())
            {
            | Integer as val
            | Literal.Enum(val, _, _) => val.ToString() == value.ToString()
            | _ => false
            }

        | _ => false
        }
    });

    match (field)
    {
    | Some(f) => f
    | None    => expression : object
    }

| Literal(Enum(_, _, field))       => field

| ConstantObjectRef(_, o : object)         // { from : MType.Class; mem : IField; }
| StaticPropertyRef(_, o : object)         // { from : MType.Class; prop : IProperty; }
| StaticEventRef   (_, o : object)         // { from : MType.Class; ev : IEvent; }
| Base                (o : object)         // { base_ctor : IMethod; }
| LocalFunRef         (o : object, _)      // { decl : LocalValue; type_parms : list [TyVar]; }
| LocalRef            (o : object)         // { decl : LocalValue; }
| MethodRef        (_, o : object, _, _)   // { obj : TExpr; meth : IMethod; type_parms : list [TyVar]; notvirtual : bool; }
| EventMember      (_, o : object)         // { obj : TExpr; ev : IEvent; }
| FieldMember      (_, o : object)         // { obj : TExpr; fld : IField; }
| PropertyMember   (_, o : object)         // { obj : TExpr; prop : IProperty; }
| DefValIn            (o : object, _, _)   // { name : LocalValue; val : TExpr; mutable body : TExpr; }
| HasType          (_, o : object)         // { expr : TExpr; test_ty : MType; }
| TypeOf              (o : object) => o    // { target_type : TyVar; }
| _                                => expression
}

| Call(name, parms) as call => 
  def func = funcMap(call);
    if (func == null)throw SomeException();
    else             func(makeParams(parms));

match (expr)
{
  | <[ if ($x) $y else $z ]> => // используем одвыражения if-а
}

B is a subclass of A, but not its subtype.

VD>>public variant Expr
VD>>{
VD>>  | Literal { value : double; }
VD>>  | Call    { name : string; parms : list[Expr]; }
VD>>  | Plus    { expr1 : Expr; expr2 : Expr; }
VD>>  | Minus   { expr1 : Expr; expr2 : Expr; }
VD>>  | Mul     { expr1 : Expr; expr2 : Expr; }
VD>>  | Div     { expr1 : Expr; expr2 : Expr; }
  
VD>>  public override ToString() : string
VD>>  {
VD>>    match (this)
VD>>    {
VD>>      | Literal(value)    => value.ToString()
VD>>      | Call(name, parms) => $"$name($(parms.Map(_.ToString()).ToString(\", \")))"
VD>>      | Plus(e1, e2) with op = "+" | Minus(e1, e2) with op = "-" 
VD>>      | Mul(e1, e2)  with op = "*" | Div(e1, e2)   with op = "/" => $"$e1 $op $e2"
VD>>    }
VD>>  }
VD>>

R>struct expr
R>{
R>    enum type {Literal, Call, Plus, Minus, Mul, Div} t;
R>    union
R>    {
R>        double value;
R>        struct {const char* name; expr* params[10]; int count;};
R>        struct {expr *expr1, *expr2;};
R>    } data;
R>};

R>void to_str(const expr* e)
R>{
R>    switch (e->t)
R>    {
R>    case expr::Literal: cout << e->data.value; break;
R>    case expr::Call: cout << e->data.name << "("; 
R>        for (int i = 0; i < e->data.count; ++i)
R>        {
R>            to_str(e->data.params[i]);
R>            cout << "," + !!i;
R>        }
R>        cout << ")"; break;
R>    case expr::Plus: to_str(e->data.expr1); cout << "+"; to_str(e->data.expr2); break;
R>    case expr::Minus: to_str(e->data.expr1); cout << "-"; to_str(e->data.expr2); break;
R>    case expr::Mul: to_str(e->data.expr1); cout << "*"; to_str(e->data.expr2); break;
R>    case expr::Div: to_str(e->data.expr1); cout << "/"; to_str(e->data.expr2); break;
R>    }
R>}
R>

R>

def plus = Expr.Plus( expr1, expr2 )

public ProcessPlus( expr: Expr.Plus )

R>

   1. (return x) >>= f == f x
   2. m >>= return == m
   3. (m >>= f) >>= g == m >>= (\x -> f x >>= g)

class List<T> {
  public void Sort (
    IComparer<T> comparer
  )
}

module List = struct
  val sort : ('a -> 'a -> int) -> 'a list -> 'a list
end

Контракты и интерефейсы тоже догмы той идиологии