Swift chaining completion Blocks

block.swift

import Foundation

protocol Performable {
  associatedtype Input
  associatedtype Output
  var action: (Input) -> (Output) { get }
  var completion: (Output) -> () { get }
  func perform(data: Input)
}

struct Action<I, O> {
  let action: (I) -> (O)
  let completion: (O) -> ()
}

extension Action: Performable {
  typealias Input = I
  typealias Output = O

  func perform(data: Input) {
    let output: Output = action(data)
    completion(output)
  }

  func chain<P:Performable> (to anotherChain: P) -> Action<Input, P.Output>
    where Output == P.Input
  {
    return Action<Input, P.Output>(action: { input -> (P.Output) in
      let firstOutput = self.action(input)
      self.completion(firstOutput)
      let secondOuput = anotherChain.action(firstOutput)
      return secondOuput
    }, completion: anotherChain.completion)
  }
}

let client = Action<String, Int>(action: { string -> (Int) in
  return Int(string)!
}) { someInt in
  print(someInt)
}

let parser = Action<Int, Float>(action: { someInt -> (Float) in
  return 11.0
}) { someFloat in
  print("Got here: \(someFloat)")
}


let chained = client.chain(to: parser)

chained.perform(data: "11")

import Foundation

class Chainable<I, O> {
func perform(data: I, callback: (O)->()) {

}

}
//a = Chainable<Int, Double>()
//b = Chainable<Double, String>()
//c = Chainable<String, Float>()
//a-->b-->c
class Cleint<String, Data> {
func perform(a: String) {
DispatchQueue.main.async {
loaddata()
callback(data)
}
}
}