class A implements I
{
    int state;
    
    void method() {}
}

class B implements I
{
    int state;
    
    void method() {}
}

// skip

void laugh(String str){
  println("haha, I'm holding an instance of " str);
}

let myString = new String("Andy");
myString.laugh();

(defmethod collide-with ((x asteroid) (y asteroid))
  ;; deal with asteroid hitting asteroid
)
(defmethod collide-with ((x asteroid) (y spaceship))
  ;; deal with asteroid hitting spaceship
)
(defmethod collide-with ((x spaceship) (y asteroid))
  ;; deal with spaceship hitting asteroid
)
(defmethod collide-with ((x spaceship) (y spaceship))
  ;; deal with spaceship hitting spaceship
)

-- для любого типа a функция f имеет тип a -> a, 
-- то есть принимает объект типа a и возвращает объект типа a
forall a. f :: a -> a

-- опс, появилась операция +, значит x должен выставлять "интерфейс", в котором определён оператор +
f x = x + 1

-- в том контексте, что a принадлежит классу типа Num,
-- функция f имеет тип a -> a
f :: Num a => a -> a

-- Оператор > определён в классе типа Ord
f :: (Ord a, Num a) => a -> a
f x = if x>0 then x+1 else x-1

if (obj instanceof A)
//
else if (obj instnceof B)
//..

IB>Ты точно на дискуссию надеялся, когда это писал?

P>>Это вообще к чему?

P>>В данном случае вам придется делать ЯВНОЕ преобразование типа, те с помощью рантаймовой инфы узнавать тип объекта, делать нужный каст и вызывать нужную функцию, либо ловить ClassCastException Какой к черту полиморфизм?

DC>Гхм... Зачем? Помнишь в С++ есть такая штука — перегрузка метода. Те типы принимаемых значений являются частью сигнатуры функции. А компилятор зная тип параметра выбирает нужную функцию. Это и есть специальный(ad hoc) полиморфизм.

class A : public Interface
{
}

class B : public Interface
{
}

void foo(A* object)
{
}

void foo(B* object)
{
}

void test()
{
Interface* object1 = new A();
Interface* object2 = new B();

foo((A)object1);
foo((B)object1);
}

f = [foo]    // возвращает результат работы ф-ии foo. Например строку "foo"
приведение к верхнему регистру:
f = [foo, upper]
добавление строки "bar" (представленной ф-ией bar) в виде каррированой ф-ии concat(x, y) { return x + y };
f = [foo, upper, lambda x: concat (x bar())]

GoJanus для FireFox

{ return ('h', {return ('e', {return ('l', {return ('l', {return ('o', null)})})})})}

\x y z -> x (y x)

class A
{
int state;
A child = new A();
ArrayList<A> childs = new ArrayList<A>();
}

D>А под ООП? Тогда уж давай говорить, что ООП — это объекты с состоянием, обменивающиеся сообщениями и ничего больше.

D>Идея очень плодотворная, но все другие, более поздние идеи, при таком подходе, к ООП отношения не имеют.

LP>class A
LP>{
LP>int state;
LP>A child = new A();
LP>ArrayList<A> childs = new ArrayList<A>();
LP>}
LP>

data List a = Nil | Cons a (List a)

Nil :: List a
Cons :: a -> List a -> List a

my_list = Cons 'a' (Cons 'b' (Cons 'c' Nil)) -- имеет тип List Char

my_list = 'a':'b':'c':[] -- имеет тип [Char]

data Tree a = Node {
    rootLabel :: a 
    subForest :: (Forest a) 
} 

type Forest a = [Tree a] -- список деревьев (type - это вроде C++ного typedef)

Node :: a -> Forest a -> Tree a

rootLabel :: Tree a -> a
subForest :: Tree a -> Forest a

data Tree a = Node a [Tree a]

old = [1,2,3]

add_head x xs = x:xs -- добавляет элемент x в голову списка xs

new = add_head 5 old -- [5,1,2,3]

old -> 1 -> 2 -> 3 -> null
       ^
       |
new -> 5

//////////// Runtime ///////////////
typedef std::string (*string_converter)(std::string);

class string_converter_node
{
public:
    string_converter_node(string_converter f)
    {
        converter = f;
        next = NULL;
    }
    string_converter converter;
    string_converter_node * next;
};

void modify_string(string_converter_node *root, string_converter f)
{
    while(root->next != NULL)
        root = root->next;
    
    root->next = new string_converter_node(f);
}

std::string get_str(string_converter_node *root)
{
    std::string cur;

    while(root != NULL)
    {
        cur = root->converter(cur);
        root = root->next;
    }

    return cur;
}


/////////////// Код приложения ///////////////////////////////
concat s1 s2 = s1 + s2

s1 = "foo"
s2 = s1
s1.concat("bar")
print s1
print s2

/////////////////////////// Транслируется в ////////////////////////

// constant "foo"
std::string foo(std::string)
{
    return "foo";
}

// constant "bar"
std::string bar(std::string)
{
    return "bar";
}

std::string concat(std::string s1, std::string s2)
{
    return s1 + s2;
}

void main()
{
    string_converter_node *s1 = new string_converter_node(foo);
    string_converter_node *s2 = s1;
    modify_string(s, lambda x: concat(x, bar));    // нужна поддержка карринга
    puts(get_str(s1).c_str());
    puts(get_str(s2).c_str());
}

GoJanus для FireFox

/////////////// Код приложения ///////////////////////////////
concat s1 s2 = s1 + s2

s1 = "foo"
s2 = s1
s1.concat("bar")
print s1
print s2

GoJanus для FireFox

Строго говоря, так и есть. Объект только тогда является объектом, когда у него есть СОСТОЯНИЕ, а состояние не может быть не изменяемым. Такой "объект" может быть с легкостью заменен на функцию, возвращающей значение.

GoJanus для FireFox