How can you show off happily without learning some higher-order functions!

[[182412]]

If you are new to functional programming, you must have heard of higher-order functions. Its Chinese explanation on Wikipedia is as follows:

In mathematics and computer science, a higher-order function is a function that satisfies at least one of the following conditions:

• Accepts one or more functions as input
• Output a function

It looks like a block or function whose input parameter or return value is a block in ObjC language, and a function whose input parameter or return value is a function in Swift language. So what role do they play in the actual development process? We will look at this issue from three aspects: input parameter, return value and comprehensive use:

Function as input parameter

It seems that using functions as input parameters is common in both the ObjC era and the Swift era. For example, AFNetworking uses two input parameter blocks to callback success and failure respectively. Swift even adds a trailing closure syntax (the last parameter is a function, and you can leave out the brackets or write it outside the brackets directly following the method name), for example, as follows:

 [1, 2, 3].forEach { item in  
 print(item)
 }

We can divide the function input parameters into two categories, escaping function input parameters and noescape function input parameters. The difference lies in whether the function input parameter is called in the execution process or outside the execution process. The function called outside the execution process is generally used for callback purposes, for example:

 Alamofire.request( "https://httpbin.org/get" ).responseJSON { response in  
    print(response.request) // original URL request
    print(response.response) // HTTP URL response
    print(response.data) // server data
    print(response.result) // result of response serialization 
 
    if let JSON = response.result.value { print( "JSON: \(JSON)" )
 }
 }

The input function of response is used as a callback returned by the network request, and will not be called when executing the responseJSON function. In addition, if we observe the code of forEach, we can infer that the input function will definitely be used during the execution of forEach, and it will have no use after execution. This type of function is a noescape function.

You should be familiar with the usage of callback. Here are some usages of noescape parameter:

1. Free Constructor

I wonder if those who have read GoF design patterns still remember the constructor pattern. The constructor pattern in Android is similar to the following:

 new AlertDialog.Builder(this)
  .setIcon(R.drawable.find_daycycle_icon)
 .setTitle( "Reminder" )
 .create ()
 .show();

1. Constructing an object requires many parameters
2. Many of these parameters have default values.
3. The properties corresponding to these parameters are not expected to be modified in the future

Then this mode can be used to display the construction process intuitively and exquisitely.

If you use the noescape parameter function, you can construct this code more simply by passing in an object with the builder as the parameter, as follows:

 // Implementation goes here class SomeBuilder { var prop1: Int  
 var prop2: Bool
 var prop3: String
    init() { // default value
 prop1 = 0
 prop2 = true  
 prop3 = "some string"  
 }
 }class SomeObj {
 private var prop1: Int  
 private var prop2: Bool
 private var prop3: String
    init(_ builderBlock:(SomeBuilder) -> Void) { let someBuilder = SomeBuilder()
 builderBlock(someBuilder) // Use of noescape parameter
        prop1 = someBuilder.prop1
        prop2 = someBuilder.prop2
        prop3 = someBuilder.prop3
 }
 } // When using let someOjb = SomeObj { builder in  
 builder.prop1 = 15
 builder.prop2 = false  
 builder.prop3 = "haha" }

2. Automatic pairing operation

Many times, we encounter APIs that must be paired to work properly during development, such as opening and closing files, entering and exiting edit mode, etc. Although Swift language provides us with syntax sugar such as defer to prevent people from forgetting pairing operations, the code still looks unpleasant.

 func updateTableView1() { self.tableView.beginUpdates() self.tableView.insertRows( at : [IndexPath(row: 2, section : 0)], with : .fade) self.tableView.deleteRows( at : [IndexPath(row: 5, section : 0)], with : .fade) self.tableView.endUpdates() // Easily missed or exceptions may occur above }func updateTableView2() { self.tableView.beginUpdates()
    defer { self.tableView.endUpdates()
    } self.tableView.insertRows( at : [IndexPath(row: 2, section : 0)], with : .fade) self.tableView.deleteRows( at : [IndexPath(row: 5, section : 0)], with : .fade)
 }

By using the noescape parameter, we can encapsulate the process to be operated, making the upper layer look more regular.

 // Extend UITableView extension UITableView { func updateCells(updateBlock: (UITableView) -> Void) {
 beginUpdates()
 defer {
 endUpdates()
 }
 updateBlock(self)
 }
 }func updateTableView() { // When used
    self.tableView.updateCells { (tableView) in  
        tableView.insertRows( at : [IndexPath(row: 2, section : 0)], with : .fade)
        tableView.deleteRows( at : [IndexPath(row: 5, section : 0)], with : .fade)
 }
 }

This is a brief introduction to functions as input parameters. Now let's take a look at functions as return values.

Function as return value

In our daily development, there are probably very few cases where functions are used as return values. However, if you can use them simply, it will make the code much cleaner.

First of all, there is no dispute that many of our APIs require functions as input parameters, whether it is the escaping input parameter or the noescape input parameter mentioned in the previous section. Therefore, many times, the code you write will have a high repetition rate, for example:

 let array = [1, 3, 55, 47, 92, 77, 801]let array1 = array.filter { $0 > 3 * 3}let array2 = array.filter { $0 > 4 * 4}let array3 = array.filter { $0 > 2 * 2}let array4 = array.filter { $0 > 5 * 5}

A piece of code that finds a number greater than the square of a certain number in an array, if not encapsulated, should look like this. For simplicity, it is usually encapsulated into the following two forms:

 func biggerThanPowWith(array: [ Int ], value: Int ) -> [ Int ] {
 return array.filter { $0 > value * value}
 } 
 
 let array1 = biggerThanPowWith(array: array, value: 3)
 let array2 = biggerThanPowWith(array: array, value: 4)
 let array3 = biggerThanPowWith(array: array, value: 2)
 let array4 = biggerThanPowWith(array: array, value: 5)

If you use the return value function of a higher-order function, you can make a higher-order function like this:

 // A function that returns ( Int ) -> Bool func biggerThanPow2With(value: Int ) -> ( Int ) -> Bool { return { $0 > value * value }
 }let array1 = array.filter(biggerThanPow2With(value: 3))let array2 = array.filter(biggerThanPow2With(value: 4))let array3 = array.filter(biggerThanPow2With(value: 2))let array4 = array.filter(biggerThanPow2With(value: 5))

You will definitely say that there seems to be no difference between the two. So here we need to talk about the advantages of using high-order return functions.

1. No need for wrapper function or opening the original class

As shown above, it is a wrapper function that takes array as an input parameter. This makes it a little uncomfortable to write and read code, after all, everyone likes OOP. If you want OOP, you must extend the original class. One way is to add an extension, or directly add a new method to the class.

2. Read the code at a glance

When using simple encapsulation, people who read the code don’t know that the filter function is used internally, and they have to check the source code to know. But when using high-order functions, people will immediately know that the filter of the system library is used.

3. Easier to reuse

This is also the most critical point. Finer-grained higher-order functions can be reused more conveniently. For example, we know that Set also has a filter method, which can be reused like this:

 let set = Set < Int >(arrayLiteral: 1, 3, 7, 9, 17, 55, 47, 92, 77, 801)let set1 = set .filter(biggerThanPow2With(value: 3))let set2 = set .filter(biggerThanPow2With(value: 9))

Recall the simple encapsulation above, is it impossible to reuse it?

There are many other examples of high-order functions that return functions. For example, the builder mentioned above. If you need to customize it to a special look every time, but a certain field is different, you can use a high-order function to easily create it:

 func builderWithDifferentProp3(prop3: String) -> (SomeBuilder) -> Void { return { builder in  
 builder.prop1 = 15
 builder.prop2 = true  
 builder.prop3 = prop3
 }
 }let someObj1 = SomeObj.init(builerWithDifferentProp3(prop3: "a" ))let someObj2 = SomeObj.init(builerWithDifferentProp3(prop3: "b" ))let someObj3 = SomeObj.init(builerWithDifferentProp3(prop3: "c" ))

After introducing the input parameters and return values, there is another combination mode, that is, the input parameter is a function and the return value is also a function. Let's take a look at this situation.

Input function && return value function

Such a function would look scary, Swift would declare it as:

 func someFunc<A, B, C, D>(_ a: (A) -> B)-> (C) -> D

Objective-C will declare

 - (id (^)(id))someFunc:(id (^)(id))block

Let's start with a small example. Recall the function biggerThanPow2With that we just made. What if we want a notBiggerThanPow2With? You know I won't write another one. So I'll tell you I'll write it like this:

 func not <T>(_ origin_func: @escaping (T) -> Bool) -> (T) -> Bool { return { !origin_func($0) }
 }let array5 = array.filter( not (biggerThanPow2With(value: 9)))

We don't need a notBiggerThanPow2With function, we just need to implement a not. Its input parameter is a (T) -> Bool, and its return value is also (T) -> Bool. We just need to use a negation when executing the block. This can not only solve the previous problem, but also solve the negation problem of any (T) -> Bool type function. For example, if we have an odd(_: int) method to filter odd numbers, we can use even=not(odd) to get a function to filter even numbers.

 func odd(_ value: Int ) -> Bool { return value % 2 == 1}let array6 = array.filter(odd)let array7 = array.filter( not (odd))let even = not (odd)let array8 = array.filter(even)

You can look at what we discussed above about biggerThanPow2With. If biggerThanPow2With is not a higher-order function that returns a function, it is not easy to process it using the not function.

In summary, if a function whose input and return values ​​are both functions is such a conversion function, it can allow us to combine more functions with less code. In addition, it should be noted that if the returned function closes the input function, then the input function is escaping input.

Next, we will show you two functions, one is the exchangeParam function, and the other is the currying function:

 func exchangeParam<A, B, C>(_ block: @escaping (A, B) -> C) -> (B, A) -> C { return { block($1, $0) }
 }func currying<A, B, C>(_ block: @escaping (A, B) -> C, _ value: A) -> (B) -> C { return { block(value, $0) }
 }

In Swift, > is a function that takes (a, b) as input, so >(5, 3) == true. When we use exchangeParam to exchange parameters, it becomes (b, a), and exchangeParam(>)(5, 3) is equal to false.

The currying function fixes the parameter b to a constant 9, so currying(exchangeParam(>), 9) means a function greater than 9.

This example uses all prefabricated functions and common functions, without any command or business function declaration, to achieve the requirement of filtering sub-arrays larger than 9 from an array. Imagine if we use more such high-order functions, many logics in the code can be more easily combined with each other, and this is the charm of functional programming.

Summarize

The introduction of higher-order functions, whether from functional programming or non-functional programming, simplifies our code to a certain extent, making our API easier to use and more reusable. However, the examples in this article are just the tip of the iceberg. More content requires continuous experimentation and innovation, and you can also deepen your understanding by learning more functional programming paradigms.

About the Author: