• lift

func lift<U, F>(transform: Signal<T, E> -> Signal<U, F>) -> SignalProducer<U, F>

运算符 |> 内部也是调用了lift方法,作用是把原producer的结果transform完返回新的类型(或原类型)／值,再封装成新的producer返回。
filter、map方法等就是使用这个。
自定义：

//属性
let age = MutableProperty<String>("0")
//自定义的方法
let stringAsInt: Signal<String,NoError> -> Signal<Int,NoError> = { signal in
            return Signal { sink in
                signal.observe(error: { sendError(sink,$0) },completed: { sendCompleted(sink) },interrupted: { sendInterrupted(sink) },next: { str in
                        sendNext(sink,(str as NSString).integerValue) })
                return nil
            }
        }
//调用
self.age.producer.lift(stringAsInt).start(next: { println("Int: \($0)") })
//效果相等于
self.age.producer
    |> stringAsInt
    |> start(next: { println("Int: \($0)") })

• concat

func concat<T,E>(next: SignalProducer<T,E>) -> SignalProducer<T,E> -> SignalProducer<T,E>

连接两个Producer，只有第一个producer销毁后才响应第二个producer。
例子：

//新建两个producer,和观察者sink
let (producer1,sink1) = SignalProducer<String,NoError>.buffer(1)
let (producer2,sink2) = SignalProducer<String,NoError>.buffer(1)
//连接两个producer 
producer1
    |> concat(producer2)
    |> start(next: { println("－> \($0)") })


sendNext(sink1,"I'm first producer")//打印 -> I'm first producer
sendNext(sink1,"I'm first producer")//打印 -> I'm first producer

sendNext(sink2,"I'm second producer")//此处不会打印，因为producer1未销毁

sendCompleted(sink1)//通知producer1已完成并销毁

sendNext(sink2,"I'm second producer")//打印 -> I'm second producer

sendNext(sink1,"I'm Parent")//不打印，因为producer1已销毁

• then

func then<T,U,E>(replacement: SignalProducer<U,E>) -> SignalProducer<T,E> -> SignalProducer<U,E>

作用跟concat差不多，但不会接收第一个producer的next事件。只有在第一个producer销毁后才会响应第二个producer。
例子：

//登录信号
let (logInSignal,sink1) = SignalProducer<String,NoError>.buffer(1)
//监控登陆状态信号
let (monitorLogInStatusSignal,sink2) = SignalProducer<String,NoError>.buffer(1)

logInSignal
    |> on(next: { /*保存登陆信息*/ })
    |> then(monitorLogInStatusSignal)//这里并不关心登陆后的用户id，所以用then 
    |> start(next: { println("-> \($0)") })

sendNext(sink1,"Prepare Login...")//不打印，因为不响应第一个producer

sendNext(sink2,"login")//不打印，因为第一个producer未completed

sendCompleted(sink1)//通知登陆完成

sendNext(sink2,"login")//打印 -> login 
sendNext(sink2,"logout")//打印 -> logout

• combineLatestWith

func combineLatestWith<T, U,E>(otherSignalProducer: SignalProducer<U, E>) -> SignalProducer<T, E> -> SignalProducer<(T, U),E>

组合两个信号，当两个都sendNext后才会返回。
之后，每当其中一个再sendNext，都会在next回调

• zipWith

func zipWith<T,E>

压缩两个信号，每当两个都sendNext一次才回在next回调一次。
例子:

let (producer1,NSError>.buffer(1)
        let (producer2,NSError>.buffer(1)

producer1
    |> zipWith(producer2)
    |> start(next: { args in
        println("-> :\(args.0)")
        println("-> :\(args.1)")
            })

sendNext(sink1,"Producer1 say hello world")    //这里不打印，必须两个信号都sendNext
sendNext(sink2,"Producer2 say hello world")//打印
sendNext(sink1,"Producer1 say hello world again")//这里不打印，必须两个信号都sendNext
sendNext(sink2,"Producer2 say hello world again")//打印

• sampleOn

func sampleOn<T,E>(sampler: SignalProducer<(),NoError>) -> SignalProducer<T,E> -> SignalProducer<T,E>

producer1
    |> sampleOn( SignalProducer<(),NoError> { sink,disposable in
    /******* Sample *******/                
    sendNext(sink,())
})

采样，当sampleOn的信号sendNext一次，就取一次producer1的最新一次sendNext的值进行next回调

• takeUntil

|> takeUntil

当传入takeUntil的信号sendNext或、sendCompleted后，将原信号设为completed。

• takeUntilReplacement

func takeUntilReplacement<T, E>(replacement: Signal<T, E>) -> Signal<T, E> -> Signal<T, E>

返回的信号会响应Next、Error、Interrupted事件。 当传入takeUntilReplacement的信号状态发生任何改变（next、error、completed等）都会disposa返回的信号