今天我们梳理了PromiseKit,于是我们根据原理和流程大体撸一个PromiseKit,大家感受一下其中的思维逻辑
enum Result<T>{
case pending
case resolved(T)
}
class Box<T>{
func inspect(b: (T)->Void){
}
func seal(_ :T)->Void{
}
}
class ABox<T>: Box<T>{
var value:Result<T>
init(value: T ) {
self.value = Result.resolved(value)
}
override func inspect(b: (T) -> Void) {
switch value {
case .pending:
break
case .resolved(let v):
b(v)
break
default:
print("none")
}
}
override func seal(_: T) {
print("seal",self,value)
}
}
protocol Able{
associatedtype T
func pipe(to:(Result<T>)->Void)
}
class A<T>: Able{
var box:ABox<Result<T>>
init(_ v:Result<T>) {
self.box = ABox.init(value: v)
}
func pipe(to:(Result<T>)->Void){
box.inspect { (v:Result<T>) in
to(v)
}
}
}
extension Able{
func then<U:Able>(_ body:(T)->U) -> A<U.T>{
let next = A<U.T>.init(.pending)
pipe { (v:Result<T>) in
print(v)
switch v {
case .pending:
print("then pending")
break
case .resolved(let value):
print(value)
let rv = body(value)
rv.pipe(to: next.box.seal)
break
}
}
return next
}
func map<U>(_ transform:(T)->U) -> A<U>{
let next = A<U>.init(.pending)
pipe { (v:Result<T>) in
switch v {
case .pending:
break
case .resolved(let value):
next.box.seal(Result.resolved(transform(value)))
break
}
}
return next
}
}
var a:A<String> = A.init(.resolved("AAAAAA"))
func firstyl<U>(exec body:()->U) -> A<U.T> where U:Able{
let rp = A<U.T>.init(.pending)
print("firstly")
body().pipe(to: rp.box.seal)
return rp
}
firstyl { () -> A<String> in
return A<String>.init(Result<String>.resolved("A"))
}.then { (msg:String) -> A<Int> in
print("msg", msg)
return A<Int>.init(Result<Int>.resolved(1))
}
func ax<T>(a:T){
print("ax", a)
}
func bx<T>(value:T, _ b:(T)->Void){
b(value)
print("bx")
}
bx(value: "ax",ax)