part 8: comparison between OOL and FL

OOP和函数编程的区别
表格：行是operation，列是variant



函数编程：
     每个operation都是一个函数，每个函数都有若干branch，每个branch都对应一个variant
     定义datatype，每个variant都对应一个constructor
面向对象编程：
     定义一个基类，每个operation是一个类函数，基类中的函数是抽象的
     每个variant是一个子类，并且实现所有的抽象函数

问题一：如果有函数带有多种类型的参数？



函数编程：
    通过wildcard pattern + helper function + case语句
面向对象编程：
     Double Dispatch

Double Dispatch
将需要知道对方的类 转化成 调用对方的函数
第一次分配：variant类应该知道自己如何做一个operation=>如Int类型就应该调用arg.add_int(self)
第二次分配：对方的add_int知道应该如何将自己和int相加
调用栈：
     add(a, b)
     a.add_values(b)
     b.add_A的类型(a自己)
     b正确处理





Multiple Dispatch
每个add_values都有自己对应的参数类型，类里会有多个add_values
当调用a.add_values(b)，将会在运行时挑选出A中接收B类型的参数的add_values, 直接调用
注意：Java和C++的static overloading虽然也能根据参数类型挑选对应函数，但是是编译期决定的，并不是运行时决定的。

多重继承：可能会在fields和methods上有冲突
     C++是支持多重继承的+abstract method
     Ruby运行有一个直接的基类和多个mixin
     Java支持一个直接的基类和实现多个接口

Mixin
类似接口，类能include mixin, 但是不能直接实例化mixin。
minxin不能有instancevariable
定义：module M … end
使用：class A < B
               include M
          end
Ruby自带的mixin: Enumerable(实现each方法)和Comparable(实现<=>方法)
     
Abstract method和high-order function的相同之处：
     都可以先定义一个框架，由client实现其中的细节。
     Abstract method是通过override函数实现的
     High-order function是通过传入函数实现的

Polymorphism:
ML中：parametric polymorphism / generics
Ruby中：subtype polymorphism / subtyping
Generic和Subtyping:
     Generic适用于 可以是任何类型的参数，但必须是同一个类型 的情况
     Subtyping适用于 有extra fields的对象的代码重用 的情况
Bounded Polymorphism:
     Generic + Subtyping
     对于depth subtype如List，可以使用List<T extend A>，这样可以修改List的内容，替换成其他的T，但是注意，都是同类型的。

Subtyping:
     让一个类型{f1:t1, f2:t2...}也是类型{f2:t2…}。前者是subtype，subtype拥有更多的信息。
     t1 <: t2: t1是t2的subtype。
     如果e是t1，那么e也是t2。t2可以理解成父类，t1是子类，子类能拥有更多的field，且子类是基类
     任何使用t2的地方都可以使用t1(t1是t2，但是t2未必是t1)
     Depth subtyping:
          如果t1<:t2, 不能让 t3 : {f1:t1} <: t4 : {f1:t2} 
          原理：如果有函数将x.f1 = t2，那么就会造成t3.f1 = t2。但是如果通过t3.f1去取t1比t2多出来的fields就会报错。
                     当有赋值的时候，depth subtyping就会出现field丢失的情况。
                     因此Java禁止赋值一个t1类型的数组内容为t2，但是允许depth subtyping
                     所有类型都可以看做是Null的subtype，所以Java中也会在运行时检查Null
      Function subtyping:不是如何调用函数，而是函数本身的委托
          如果 ta <: tb，则函数t->ta <: t->tb。能返回更多fields(promise more)的函数可以替换。return type: covariant(works the same way)
          如果 ta <: tb，则函数tb->t <: ta->t。需要更少fields(need less)的函数可以替换。argument type: contravariant(works the oposite way)
          除了self/this这个参数，由于实现问题必须是subtype，不能使contravariant的
     OOP中的subtype:
          因为field能够修改，所以subtype的field类型不能改变（原因参照depth subtyping）
          因为methods不能修改，所以subtype的methods能够使用supertype对应函数的subtype     
     Subclass和subtype不同：
          class：定义了对象的行为，子类通过继承并extend/override这些behavior
          type：定义了对象的类型和能够响应的消息，子类型是为了替换父类型并且防止发生错误。