interface IEnumerable{ void Foo();}
interface ICollection:IEnumerable{void Bar();}

ICollection GetItems(){..}

var items = GetItems();
items.Foo();
items.Bar();

interface IEnumerable{ void Foo();}
interface ICollection{void Bar();}

ICollection GetItems(){..}

var items = GetItem();
((IEnumerable)items).Foo();
items.Bar();

class Functor f => Applicative f where
    return :: x -> f x
    (<*>) :: f (s -> t) -> f s -> f t
    (>>) :: f s -> f t -> f t
    fs >> ft = return (flip const) <*> fs <*> ft
    -- описываем дефолтный инстанс для суперкласса.
    instance Functor f where
        fmap = (<*>) . return
        
class Applicative f => Monad f where
    (>>=) :: f a -> (a -> f b) -> f b
    instance Applicative f where
        ff <*> fs = ff >>= \f -> fs >>= \s -> return (f s)

class DFunctor f where
    dmap :: (a -> b) -> f a -> f b
    default dmap :: DMonad f => (a -> b) -> f a -> f b
    dmap f = dbind (dreturn . f)
    
class DApplicative f where
    dpure :: a -> f a
    default dpure :: DMonad f => a -> f a
    dpure = dreturn
    dap :: f (a -> b) -> f a -> f b
    default dap :: DMonad f => f (a -> b) -> f a -> f b
    dap ff fs = ff `dbind` \f -> fs `dbind` \s -> dreturn (f s)

class DMonad m where
    djoin :: m(m a) -> m a
    djoin = dbind id
    
    dbind :: (a -> m b) -> m a -> m b
    default dbind :: DFunctor m => (a -> m b) -> m a -> m b
    dbind f = djoin . dmap f
    
    dreturn :: a -> m a
    default dreturn :: DApplicative m => a -> m a
    dreturn = dpure
    
-- теперь, если у нас есть инстанс DMonad, то инстансы для 
-- DFunctor и DApplicative не нужно реализовывать, только
-- указать, что они нам нужны:

instance DFunctor []
instance DApplicative []

-- Или, если есть инстансы для DFunctor и DApplicative,
-- нужно реализоватьтолько тот минимум, который добавляет DMonad:

instance DMonad [] where
    join = concat

type NumAndEq a = (Num a, Eq a)

foo :: NumAndEq a => a -> a -> Bool
foo a b = a * b == a

//было IPet Get() - стало:
{exist T where T : IPet} Get()
T Get<exist T>() where T : IPet // или так
{
    // было return ((IPet) new Cat()); стало:
    return {Cat, new Cat()}; // вводим (упаковываем)
}

// так нельзя
void Foo<forall T1>(Action<T1> kill) where T1 : IPet
// нужны rank-2 типы:
void Foo(Action<forall T1> kill) where T1 : IPet
{
    var {T2, pet} = Get(); // элиминируем (распаковываем)
    // после этого биндинга можно использовать T2:
    kill<T2>(pet);
}

// но вот так нельзя:
T2 Foo(Action<forall T1> kill) where T1 : IPet
//ошибка: T2 за пределами области видимости
// так можно:
{exist T where T : IPet} Foo(Action<forall T1> kill) where T1 : IPet

ВВ>interface IMessenger
ВВ>{
ВВ>    void SendMessage(string text);
ВВ>}

ВВ>interface IFileSender
ВВ>{
ВВ>    void SendFile(File file);
ВВ>}

ВВ>class SkypeMessenger : IFileSender, IMessenger;
ВВ>class SmsMessenger : IMessenger;

ВВ>...
ВВ>void SurpriseAdminInChief<T>(T messenger) where T : IFileSender, IMessenger

ВВ>void SurpriseApprenticeAdmin(IMessenger messenger)
ВВ>

interface IFileSenderFactory
{
    IFileSender Create();
}

class MyApp : Application
{
    IFileSender AdvancedMessenger
    {
        get; set;
    }
}

ВВ>interface IMessenger
ВВ>{
ВВ>    void SendMessage(string text);
ВВ>}

ВВ>interface IFileSender
ВВ>{
ВВ>    void SendFile(File file);
ВВ>}

interface IEnumerable {}
interface ICollection : IEnumerable {}
interface IList : ICollection {}

interface IEnumerable { }
interface ICollectionPure { }
interface IListPure { }

alias ICollection = IEnumerable | ICollectionPure;
alias IList = ICollectionPure | IListPure;

2 + 2
12.2 + 12.2

open string

trimChars '!' '?' "!string?"
trimChars '!' "string?"

test1 =
  test "Integer equality"
  given 2
    should be 2
    shouldn't be 33

interface ByteReader {
  func Read(buffer byte[], length uint64) (read uint64)
}

interface ByteWriter ...

interface File {
  ByteReader
  ByteWriter
  open,close...
}

interface NetworkConnection {
  ByteReader
  ByteWriter
  bind,connect...

trait A { def foo: String }
trait B { def bar: String }

def getIt: A with B =
  new A with B {
    def foo = "hello"
    def bar = "world"
  }

T Something<T>(T val) where T : IFoo, IBar
{
  ...
}

// Any protocol supports plain text.
interface IMessenger
{
    void SendMessage(string text);
}

// No protocols support file transport only. If there is one, the contract is not valid anymore.
interface IFileSender : IMessenger
{
    void SendFile(File file);
}

class SkypeMessenger : IFileSender; // It's easy to support both text and file sending via Skype.
class SmsMessenger : IMessenger; // ...But not via SMS.

class MyApp : Application
{
...
void SurpriseAdminInChief(IFileSender messenger)
{
    messenger.SendFile(_dumpFile);
    messenger.SendText(_criticalErrorMessage); // We are absolutely sure we can send text if we can send files.
}
void SurpriseApprenticeAdmin(IMessenger messenger)
{
    messenger.SendText(_warningMessage);
}
...
}

interface IMessenger
{
    void SendMessage(string text);
}

interface IFileSender
{
    void SendFile(File file);
}

class SkypeMessenger : IFileSender, IMessenger;
class SmsMessenger : IMessenger;

...
void SurpriseAdminInChief<T>(T messenger) where T : IFileSender, IMessenger

void SurpriseApprenticeAdmin(IMessenger messenger)

SV.>class MyApp : Application
SV.>{
SV.>    IFileSender AdvancedMessenger
SV.>    {
SV.>        get; set;
SV.>    }
SV.>}
SV.>

interface IMessenger<T> where T : IMessage
{
   void Send(T);
}

IEnumerable S1<T1, T2>(this IEnumerable items, Func<T1, T2> transformer)
{
  foreach (var item in items)
    yield return transformer(item);
}
ICollection S1<T1, T2>(this ICollection items, Func<T1, T2> transformer)
{
   return new LazyCollection(items.Count, items.S1(transformer));
}

...

type Reader interface {
    Read(b []byte) (n int, err error)
}

type Writer interface {
    Write(b []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

type SectionReader struct {
    ...
}

func (s *SectionReader) Read(p []byte) (n int, err error) {
    ....
}

func some_func(rw ReadWriter) {
    ...
}
...

INum
{
  Add,
  Subtract,
  Multiply
}

IFractional [ : INum ]
{
  Divide
}

interface Drawable
{
    void draw(Canvas);
}

interface Interactable extends Drawable
{
    void add_event_listener(function<void (Event)>);
}

class Label implements Drawable
{
    void set_title(string);
}

class Button implements Interactable
{
    void set_title(string);
    void set_action(function<void (ClickEvent)>);
}

interface ScreenEvent extends Event
{
    Point get_position();
    Interactable get_target();
}

DG>IEnumerable S1<T1, T2>(this IEnumerable items, Func<T1, T2> transformer)
DG>{
DG>  foreach (var item in items)
DG>    yield return transformer(item);
DG>}
DG>ICollection S1<T1, T2>(this ICollection items, Func<T1, T2> transformer)
DG>{
DG>   return new LazyCollection(items.Count, items.S1(transformer));
DG>}
DG>

C<E2> Map<C,E1,E2>(C<E1> seq, Func<E1,E2> fun)
{
 ...
}

public interface IMapable<E1>
{
  IMapable<E2> Map<E2>(Func<E1,E2> fun);
}

LazyCollection S1<T1, T2>(this LazyCollection items, Func<T1, T2> transformer)
{
   return new LazyCollection(items.Count, items.S1(transformer));
}

This Object-Oriented feature allows substituting a particular implementation using the same interface, and therefore it enables polymorphism.

_NN>interface IEnumerable {}
_NN>interface ICollection : IEnumerable {}
_NN>interface IList : ICollection {}
_NN>

_NN>interface IEnumerable { }
_NN>interface ICollectionPure { }
_NN>interface IListPure { }

_NN>alias ICollection = IEnumerable | ICollectionPure;
_NN>alias IList = ICollectionPure | IListPure;
_NN>

_NN>Так и к структурной типизации придем

type ICollection = IEnumerable & ICollectionPure;

ICollection coll = ...;

IA&IB variable1 = ...;
IA variableA = variable1;// ~upcast

type IEnumerable_Or_ICollectionPure  = IEnumerable | ICollectionPure;

IA|IB variable3 = ...;
match(variable3)
{
 | a is IA => ...
 | b is IB => ...
}
//Возможно
variable3.F();//,если  F() есть в обоих интерфейсах (хотя тут подумать надо)

(IA&IB)|IC variable4 = ...;