Currying

[JD-man]

정의

• 매개변수를 여러개 받는 함수를 1개의 매개변수를 사용하는 함수의 chain으로 만드는 작업.
• 고차함수 사용시 매개변수로 다른 함수를 사용해야하는 경우 리턴타입에 유의해야한다.
• 리턴타입에 유의하다보면 다른 함수가 매개변수를 많이 가져야하는 경우가 생길 수 있는데 이를 막아줄 수 있다.

예시

Currying 이전

func aHigherOrderFunction(_ operation: (Int) -> ()) {
  let numbers = 1...10
  numbers.forEach(operation)
}

func someOperation(_ p1: Int, _ p2: String) {
  print("number is: \(p1), and String is: \(p2)")
}

aHigherOrderFunction { someOperation($0, "a constant") }

• aHigherOrderFunction은 2개의 매개변수를 가지는 someOperation 함수를 매개변수로 가지는 고차함수

Currying 이후

func curried_SomeOperation(_ p1: Int) -> (String) -> () {
  return { str in
    print("number is: \(p1), and String is: \(str)")
  }
}

• curried_SomeOperation은 1개의 매개변수를 가지고 (String) -> ()를 리턴하는 함수
• 이런 경우 특히 Retain cycle에 유의해야한다

aHigherOrderFunction { curried_SomeOperation($0)("a constant") }

• 이제 aHigherOrderFunction { someOperation($0, "a constant") }에서 클로저 안쪽을 위와 같이 나눠서 사용할 수 있다.

Flipping

func curried_SomeOperation(_ str: String) -> (Int) -> () {
  return { p1 in
    print("number is: \(p1), and String is: \(str)")
  }
}

aHigherOrderFunction(curried_SomeOperation("a constant"))

• 다른 함수의 리턴타입을 고차함수의 파라미터 타입과 같게 한다면 클로저를 사용하지 않고 currying이 가능하다.

[JD-man]

A generic currying function

func curry<A, B, C>(
  _ originalMethod: @escaping (A, B) -> C
) -> (A) -> (B) -> C {
  return { a in
    { b in
      originalMethod(a, b)
    }
  }
}

• 두개의 파라미터를 받는 메서드를 currying 해주는 generic fuction이다.

someOperation(1, "number one")
curry(someOperation)(1)("number one")

• 위와 같이 사용해서 currying을 한다.

[JD-man]

Generic argument flipping

func flip<A, B, C>(
  _ originalMethod: @escaping (A) -> (B) -> C
) -> (B) -> (A) -> C {
  return { b in { a in originalMethod(a)(b) } }
}

• currying된 메서드를 이용해 flipping한다.

let curried = curry(someOperation)
let flipped = flip(curried)
aHigherOrderFunction(flipped("a constant"))

• 위와 같이 사용 가능

[JD-man]

Class Method Flipping

extension Int {
  func word() -> String? {
    let formatter = NumberFormatter()
    formatter.numberStyle = .spellOut
    return formatter.string(from: self as NSNumber)
  }
}

[1, 2, 3, 4, 5].map { $0.word() }
// [Optional("one"), Optional("two"), Optional("three"), Optional("four"), Optional("five")]

• 위와 같이 Int의 extension으로 word()라는 메서드가 만들었을때 map을 사용하려면 클로저를 사용한다.

Class Method

Int.word 
// (Int) -> () -> Optional<String>

Int.word(1)() // one
Int.word(10)() // ten
Int.word(36)() // thirty-six

• 스위프트는 자동으로 타입 메서드를 만들어주며 위와 같이 사용된다.
• 이때 Flipping을 이용하면 클로저 없이 map 사용이 가능해진다.

func flip<A, C>(
  _ originalMethod: @escaping (A) -> () -> C
) -> () -> (A) -> C {
  return { { a in originalMethod(a)() } }
}

• 위와 같은 Generic flip 메서드를 정의하면

var flippedWord = flip(Int.word)()
[1, 2, 3, 4, 5].map(flippedWord)
// ["one", "two", "three", "four", "five"]

• 클래스 메서드를 flipping해 클로저 없이 map을 사용할 수 있다.
• 예시로 map을 사용하지만 여러 고차함수들도 이와 같이 사용 가능할 것으로 생각된다.

func reduce<A, C>(
  _ originalMethod: @escaping (A) -> () -> C
) -> (A) -> C {
  return { a in originalMethod(a)() }
}

var reducedWord = reduce(Int.word)

• Void가 중간에 사용되는 경우에는 위와 같은 reduce 메서드를 통해 축약이 가능

[JD-man]

Generic Function Merger

func mergeFunctions<A, B, C>(
  _ f: @escaping (A) -> () -> B,
  _ g: @escaping (B) -> () -> C
) -> (A) -> C {
  return { a in
    let fValue = f(a)()
    return g(fValue)()
  }
}

func +<A, B, C>(
  left: @escaping (A) -> () -> B,
  right: @escaping (B) -> () -> C
) -> (A) -> C {
  return { a in
    let leftValue = left(a)()
    return right(leftValue)()
  }
}

• 두 메서드를 위와 같은 메서드를 통해서 합성시킬 수 있다.
• 예시의 메서드들은 똑같이 두 메서드를 합성시키지만 후자의 경우 오버로딩을 통해 연산자를 사용한다

extension Int {
  func word() -> String? {
    let formatter = NumberFormatter()
    formatter.numberStyle = .spellOut
    return formatter.string(from: self as NSNumber)
  }

  func squared() -> Int {
    return self * self
  }
}

var mergedFunctions = mergeFunctions(Int.squared, Int.word)
mergedFunctions(2) // four

var addedFunctions = Int.squared + Int.word
addedFunctions(2) // four
(Int.squared + Int.word)(2) // four