a.function(b);

class A
{
    void function(B _b)//чтобы установить отношения a.function(b), должно выполняться соотношение b is-a B
    {
        _b.foo();
    }
}

class A
    def function(b)  //чтобы установить отношения a.function(b), не должно выполняться никаких соотношений, но...
        b.foo;       //...вот здесь потребуется соотношение b can foo

Ты путаешь *типизацию* и *статическую типизацию*.

Статическая типизация — правила типизации проверяются на этапе компиляции.
Динамическая типизация — правила типизации проверяются на этапе выполнения.
Сильная типизация — правила типизации энфорсятся всегда.
Слабая типизация — правила типизации энфорсятся с заранее оговоренными
исключениями

someAlgorithmOn: aCollection
    ...
    found := aCollection contains: xxx.
    ...

MinimalContainerUniverse
    contains: anElement
        ^true

someAlgorithm: aMinimalContainer
    ...
    found := aMinimalContainer contains: xxx.
    ...

a.function(b);

ЗХ>class A
ЗХ>{
ЗХ>    void function(B _b);  //все равно нужно задать, к какому типу должен относиться аргумент
ЗХ>}

ЗХ>...
ЗХ>a.function(b);//но вот относится ли он к этому типу - может меняться динамически, в run-time
ЗХ>...
ЗХ>

class A
{
    public void function( Object untyped )
    {
        // Вот здесь работает динамическая типизация.
        B b = (B)untyped;
        // А вот здесь уже статическая.
        b.something();
    }
};

ЗХ>Во! Начинает проясняться! А как насчет людей, который опровергают это утверждение, цитируюя тебя же?

ЗХ>a.function(b);
ЗХ>

doesNotUnderstand: aMessage
   aMessage selector = #function:
      itTrue:
         [Transcript print: aMessage arguments first.
         ^nil].
   ^super doesNotUnderstand: aMessage

var s=0;
var s1=0.0L;

_>Верно. Более того, приведу первоначальное определение ООП по Кею

//Скажем, в C++, видя запись
a+b
//мы можем ожидать, что определен либо
a.operator+(b);
//либо 
operator+(a,b);

//а в D, к слову, может быть
a.opAdd(b)
//или
b.opAdd_r(a)

//вот в этом случае:
a.function(b);
//обязательно наличие именно (1)
a.function(b);
//но не (2)
function(a,b);
//и не (3)
b.function_r(a);

c = a+b;

c = a.operator+(b);

c = b.operator+(a);

c.ClacSumAndAssign(a, b); // Чур меня, чур...

CFigureArr* CSegment::GetIntersections(CSegment &other); // отрезок с отрезком
CFigureArr* CLine::GetIntersections(CSegment &other); // прямая с отрезком
CFigureArr* CCircle::GetIntersections(CSegment &other);
CFigureArr* CEllipse::GetIntersections(CSegment &other);
CFigureArr* CPolyLine::GetIntersections(CSegment &other);
CFigureArr* CBezier::GetIntersections(CSegment &other);
CFigureArr* CArc::GetIntersections(CSegment &other);
CFigureArr* CPoint::GetIntersections(CSegment &other); // Так, для комплекта
// а теперь весело, с улыбочкой, всё то же самое с прямой
CFigureArr* CSegment::GetIntersections(CLine &other);
CFigureArr* CLine::GetIntersections(CLine &other);
// ................. и т.д.