Why OO sucks

个人感觉。从来没有觉得对象能够表达现实世界的任何东西。对象只能表达编程元素。
能够打包，确实是OO的好处。尤其是带有多态的打包。
打包很简单。C语言、FP语言都可以打包（放到Tuple、Array里面）。

打包是为了啥呢？为啥OO的打包就那么特殊呢？OO打包的特点在于多态。
多态是为了啥呢？是为了 callback 模式形式的重用。也叫做Template模式。
在callback (or template) 重用模式下，OO是无敌王者。

template( callback) { // 这里重用的是template
.....

callback.run(....)
.....
}

可惜，只依靠这一点，并不足以击败FP。FP的函数直接就可以作为参数和返回值，在callback重用模式更有优势。
OO只能依靠来自于C语言的状态（可重复赋值）特性来击败FP。
OO的打包可以很自然地携带数据（有状态），同时具有多态。

FP的打包，可以分为两种。
(1) Funciton本身。这种情况下，callback重用有优势。甚至优于OO对象。但是，携带数据不方便，只能依靠闭包。而闭包是很麻烦，很不直观的。

(2) Tuple, Array里面放数据和函数。这种情况下，callback重用就比较麻烦，必须自己在template函数外部手工替换Tuple中的某一个Function。而不能达到OO多态那样的自然简单效果。

OO的打包可以很自然地携带数据（有状态），同时具有多态

class Entity a where
getPosition :: a -> (Int,Int)
getVelocity :: a -> (Int,Int)
getAcceleration :: a -> (Int,Int)
getColor :: a -> Color
getShape :: a -> Shape

data Paddle =
Paddle { paddlePosX, paddlePosY,
paddleVelX, paddleVelY,
paddleAccX, paddleAccY :: Int,
paddleColor :: Color,
paddleHeight :: Int,
playerNumber :: Int }

instance Entity Paddle where
getPosition p = (paddlePosX p, paddlePosY p)
getVelocity p = (paddleVelX p, paddleVelY p)
getAcceleration p = (paddleAccX p, paddleAccY p)
getColor = paddleColor
getShape = Rectangle 5 . paddleHeight

~(P,F)=F(p)

P~F

只要有类型就能做polymorphism,和是否OO,fp没有关系.
比如这样

class Entity a where
getPosition :: a -> (Int,Int)
getVelocity :: a -> (Int,Int)
getAcceleration :: a -> (Int,Int)
getColor :: a -> Color
getShape :: a -> Shape

data Paddle =
Paddle { paddlePosX, paddlePosY,
paddleVelX, paddleVelY,
paddleAccX, paddleAccY :: Int,
paddleColor :: Color,
paddleHeight :: Int,
playerNumber :: Int }

只要有类型就能做polymorphism,和是否OO,fp没有关系.
比如这样

class Entity a where
getPosition :: a -> (Int,Int)
getVelocity :: a -> (Int,Int)
getAcceleration :: a -> (Int,Int)
getColor :: a -> Color
getShape :: a -> Shape

data Paddle =
Paddle { paddlePosX, paddlePosY,
paddleVelX, paddleVelY,
paddleAccX, paddleAccY :: Int,
paddleColor :: Color,
paddleHeight :: Int,
playerNumber :: Int }

你要做出OO的.操作符也很简单
做一个中缀函数就完了

从OO的角度来看，上述这些是 Overload (函数参数类型不同)。

OO的多态是override实现的，函数参数类型是一样的。

有了polymorphism，要override干嘛呢?

有了polymorphism，要override干嘛呢?

这是Haskekell的类型定义吧。
能不能给一个类型继承的例子。OO多态就是依靠inherit（对于interface叫做implement）来实现的。

比如，两个类型只有一个方法不同，其他方法都是相同的。

function dog(method){
    if(method == 'say'){
         return function(){
             alert('dog dog dog');
         }
    } else if(method == 'look'){
         return function(){
            alert('还行');
         }
    }
}

function habadog(method){
    if(method == 'look')  // 覆盖 look 方法
       return function(){alert('漂亮');}
    else
       return dog(method)
}

function dog(method){
    if(method == 'say'){
         return function(){
             alert('dog dog dog');
         }
    } else if(method == 'look'){
         return function(){
            alert('还行');
         }
    }
}

function habadog(method){
    if(method == 'look')  // 覆盖 look 方法
       return function(){alert('漂亮');}
    else
       return dog(method)
}

闭包是FP语言的一种携带数据的迫不得已的方案。而且，不能“定义”类型，只能动态“产生”类型。
闭包产生类型，不如OO定义类型那么直观和便利。