Function currying

Function currying translates a single function with multiple arguments into a series of functions each with one argument. Let's examine an example.

Suppose that we have a function that combines firstName and lastName to return the full name as follows:

func extractFullName(firstName: String, lastName: String) -> String { 
    return "\(firstName) \(lastName)" 
} 

This function could be translated into a curried function as follows:

func curriedExtractFullName(firstName: String)(lastName: String) -> String { 
    return "\(firstName) \(lastName)" 
} 

As seen from this example, we replace the comma with ) ( parentheses. So now we can use this function as follows:

let fnIncludingFirstName = curriedExtractFullName("John") 
let extractedFullName = fnIncludingFirstName(lastName: "Doe") 

Here, fnIncludingFirstName will already have firstName in it so that, when we use it, we can provide lastName and extract the full name.

Starting with Swift 2.2, Apple deprecated function currying and removed it from Swift 3.0. We can convert the function currying to returning a closure explicitly:

// Before: 
func curried(x: Int)(y: String) -> Float { 
    return Float(x) + Float(y)! 
} 

// After: 
func curried(x: Int) -> (String) -> Float { 
    return { 
        (y: String) -> Float in 
        return Float(x) + Float(y)! 
    } 
} 

Let's convert our curried function to return the closure version explicitly:

func explicityRetunClosure(firstName: String) -> (String) -> String { 
    return { 
        (lastName: String) -> String in 
        return "\(firstName) \(lastName)" 
    } 
} 

We can use this function as follows and the result is going to be identical:

let fnIncludingFirstName = explicityRetunClosure(firstName: "John") 
let extractedFullName = fnIncludingFirstName("Doe")