图库 (Túkù)

实现 (Shíxiàn)

Monad

>>- (flatMap) (左结合) (Zuǒ jiéhé)

public func >>- <A, B>(a: EventLoopFuture<A>, f: @escaping (A) -> EventLoopFuture<B>) -> EventLoopFuture<B>

-<< (flatMap) (右结合) (Yòu jiéhé)

public func -<< <A, B>(f: @escaping (A) -> EventLoopFuture<B>, a: EventLoopFuture<A>) -> EventLoopFuture<B>

>=> Monad 的从左到右 Kleisli 组合 (左结合) (Monad de cóng zuǒ dào yòu Kleisli zǔhé (Zuǒ jiéhé))

public func >=> <A, B, C>(f: @escaping (A) -> EventLoopFuture<B>, g: @escaping (B) -> EventLoopFuture<C>) -> (A) -> EventLoopFuture<C>

<=< Monad 的 Kleisli 组合 (右结合) (Monad de Kleisli zǔhé (Yòu jiéhé))

public func <=< <A, B, C>(f: @escaping (B) -> EventLoopFuture<C>, g: @escaping (A) -> EventLoopFuture<B>) -> (A) -> EventLoopFuture<C>

Functor

<^> (map) (左结合) (Zuǒ jiéhé)

public func <^> <A, B>(a: EventLoopFuture<A>, f: @escaping (A) -> B) -> EventLoopFuture<B>

Applicative

<*> Applicative

public func <*> <A, B>(f: EventLoopFuture<((A) -> B)>, a: EventLoopFuture<A>) -> EventLoopFuture<B>

用法 (Yòngfǎ)

func get(with client: RedisClient, for data: RedisData) -> Future<RedisData> {
        return client.command("GET", [data])
}

private func terse(_ req: Request) throws -> Future<RedisResponse> {
        let client = try req.make(RedisClient.self)
        return get(with: client, for: "KEY")
            >>-  curry(get)(client)
            >>-  curry(get)(client)
            >>-  curry(get)(client)
            <^> RedisResponse.init
}

与 (Yǔ)

 private func nested(_ req: Request) throws -> Future<RedisResponse> {
        let client = try req.make(RedisClient.self)
        return client.command("GET", ["key"]).flatMap(to: RedisResponse.self) { data in
            return client.command("GET", [data]).flatMap(to: RedisResponse.self) { data in
                return client.command("GET", [data]).map(to: RedisResponse.self) { data in
                    return RedisResponse(data)
                }
            }
        }
    }

Monad 的 Kleisli 组合 (Monad de Kleisli zǔhé)

>=> 是函数的 Monad 版本组合。(>=> shì hánshù de Monad bǎnběn zǔhé.)

func query(with: String) -> EventLoopFuture<Int> {
    return EventLoopFuture(2)
}

func updateCache(with id: Int) -> EventLoopFuture<String> {
    return EventLoopFuture("Success")
}

let queryAndUpdate = query >=> updateCache

Applicative

将 future 函数应用于 future 值 (Jiāng future hánshù yìngyòng yú future zhí)

柯里化 (Kē lǐ huà)

柯里化是一种将接受多个参数的函数转换为一系列函数的求值技术，每个函数都只有一个参数。(Kē lǐ huà shì yī zhǒng jiāng jiēshòu duō gè cānshù de hánshù zhuǎnhuàn wéi yī xìliè hánshù de qiúzhí jìshù, měi gè hánshù dōu zhǐyǒu yīgè cānshù.)

 let renderer: (String, Encodable) -> Future<View> = try req.make(LeafRenderer.self).render
 
 curry(renderer) //(String) -> (Encodable) -> Future<View>
 overview >>- curry(renderer)("overview")

这对于将运算符与非一元函数一起使用很有用。(Zhè duìyú jiāng yùnsuàn fú yǔ fēi yīyuán hánshù yīqǐ shǐyòng hěn yǒuyòng.)

SwiftPM

.package(url: "https://github.com/John-Connolly/terse.git", from: "1.0.0")