前言

ReactiveCocoa是一个FRP的思想在Objective-C中的实现框架。FRP即Functional Reactive Programming。
ReactiveCocoa 是基于函数式编程中一个叫Monad概念。这篇文章主要讲什么是Monad。
文中的代码以Haskell演示。
提及Monad通常会涉及到Functor, Applicative 他们三个经常一起出现，我们将依此讲解。

函数式编程中的一些概念背景知识

Typeclass

Typeclass 类似于Java中的接口，OC中的协议。
Typeclass 中定义了一些函数，实现一个typeclass就是要实现这些函数。
所有实现了这个typeclass的数据类型都拥有这些共同的行为。
定义Typeclass

class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    x == y = not (x /= y)
    x /= y = not (x == y)

定义一个叫做Eq的typeclass。 a 一个型别变量，他代表a是任何我们在定义instance时的型别。然后又定义了4个函数。

Maybe

Maybe类型封装了一个可选值，一个 Maybe a 类型的值要么包含一个a 类型的值(Just a)，要么为空(Nothing表示)。
Maybe看作一个上下文，这个上下文表示某次计算可能成功，也可能失败，成功是用(Just a)表示，失败时用Nothing表示。

提出问题

假设有一个值2，如何将函数(+3) 应用到这个值上？
幼儿园加法，大家都知道吧。
如果值2是一个上下文值呢？
那就需要使用Functor。

Functor typeclass

//1. Functor typeclass
class Functor f where
  fmap :: (a->b)->f a -> f b
 
//2. Maybe Functor (即假设f 是Maybe)
class Functor Maybe where
  fmap :: (a ->b) -> Maybe a -> Maybe b
 
//3. Maybe Functor 实现
instance Functor Maybe where
  fmap func (Just x) = Just (func x)
  fmap func Nothing = Nothing
 
//4. Haskell 运行效果
*Main> fmap (+3) Nothing 
Nothing
*Main> fmap (+3) (Just 2)
Just 5

注释: 方法fmap有两个参数：
参数一：(a->b) 表示一个函数，函数的需要一个参数，输入运行结果b
参数二：f a 其中f是参数a的类型限制。比如：假如f 是Maybe，则a 要么是Nothing，要么是Just a
在 3 instance 中运用了模式匹配，当参数为Just x 时调用第一行。参数为Nothing时调用第二行。

问题又来了

如果函数(+3) 也在上下文中呢？比如Maybe，此时(+3) 就变成了Just(+3)
那就需要Applicative。

Applicative typeclass

//1. Applicative typeclass
class Functor f => Applicative f where
    pure :: a - > f a
    (<*>) :: f (a -> b) -> f a -> f b
 
//2. Maybe Applicative
class Functor Maybe => Applicative Maybe where
    pure :: a -> Maybe a
    (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b
 
//3. Maybe Applicative 实现
instance Applicative Maybe where
    pure :: Just
    Nothing <*> _ = Nothing
    (Just func) <*> something = fmap func something
 
//4. Haskell 运行效果
*Main> (<*>) (Just (+3)) (Just 2)
Just 5
*Main> (<*>) (Just (+3)) Nothing 
Nothing

注释：=> 符号解释： =>左边的部分叫型别约束。即 Applicative 中 f 的型别是Functor

总结一下

Fouctor: 应用一个函数到一个上下文中的值，返回一个上下文中的值。
Applicative: 应用一个上下文中函数到一个上下文中的值，返回一个上下文中的值。

那么Monad是干什么呢

Monad：应用一个函数到一个上下文的值。并返回一个在上下文的值的函数。

//1. Monad classtype
class Applicative m => Monad m where
    return :: a -> m a
    (>>=) :: m a -> m b -> m b
 
//2. Maybe Monad
class Applicative Maybe => Monad Maybe where
    return :: a -> Maybe a
    >>= :: Maybe a -> (a -> Mayb b) -> Maybe b
 
//3. Maybe Monad 实现
instance Monad Maybe where
    return x = Just x
    Nothing >>= func = Nothing
    Just x >>= func = func x
 
//4. Haskell 运行效果
    //4.1 定义一个函数
    half x = if even x
        then Just (x `div` 2)
        else Nothing
     
    //4.2 运行效果
    *Main> Just 20 >>= half 
    Just 10
    *Main> Just 10 >>= half 
    Just 5
    *Main> Just 5 >>= half 
    Nothing
 
    //4.3 链式操作
    *Main> Just 20 >>= half >>= half >>= half
    Nothing

三者之间的联系

Applicative是增强型的Functor。
Monad是增强型的Applicative。

再总结一下

一个Functor 就是实现了Functor typeclass 的数据类型。
一个Applicative 就是现实了 Applicative typeclass 的数据类型。
一个Monad 就是实现了Monad typeclass的数据类型。

ReactiveCocoa

开头讲了ReactiveCocoa是基于函数式响应式的编程思想。基于Monad的思想。我们具体来看一下。
我们知道，RAC的核心概念是Signal而Signal继承自 RACStream，看一下RACStream源码：

@interface RACStream : NSObject
+ (instancetype)empty;
 
 
// 主要看这里
+ (instancetype)return:(id)value;
- (instancetype)bind:(RACStreamBindBlock (^)(void))block;
 
 
- (instancetype)concat:(RACStream *)stream;
 - (instancetype)zipWith:(RACStream *)stream;
@end

我们可以看到 RACStream 中有两个方法

+ (instancetype)return:(id)value;
- (instancetype)bind:(RACStreamBindBlock (^)(void))block;

return:方法的功能就是将一个值 value放入 RACStream上下文中；
bind:方法的功能则是将一个 RACStreamBindBlock类型的 block应用到一个在 RACStream上下文中的值（receiver），并返回另一个在 RACStream
上下文中的值。
注，RACStreamBindBlock类型的 block就是一个接收一个普通值 value但是返回一个在 RACStream上下文中的值的“函数”；

RACStream与Monad 比较一下

// 1. Monad 定义
class Applicative m => Monad m where
    return :: a -> m a
    (>>=) :: m a -> (a -> m b) -> m b
 
//2. 假设m 是RACStream 类型
class Applicative RACStream => Monad RACStream where
    return :: a -> RACStream a
    (>>=) :: RACStream a -> (a -> RACStream b) -> RACStream b

其中:
return :: a -> RACStream a就对应 + (instancetype)return:(id)value;
(>>=) :: RACStream a -> (a -> RACStream b) -> RACStream b
则对应 - (instancetype)bind:(RACStreamBindBlock (^)(void))block;

是不是一样一样的。

参考资料：

http://blog.leichunfeng.com/blog/2015/11/08/functor-applicative-and-monad/
《Haskell趣学指南》

ReactiveCocoa 与函数式编程有什么关系？

前言