Swift Higher Order Functions Filter, Map, Reduce, Flatmap and CompactMap

Map, filter, reduce, Flatmap and  CompactMap drop in Swift. Simple Higher Order Function

Higher order functions are simply functions that operate on other functions by either taking a function or closures as an argument, or returning a function. That can be used on collection types such as Array or Dictionary

Map : - "Use map to loop over a collection and apply the same operation to each element in the collection. The map function returns an array containing the results of applying a mapping or transform function to each item:"

That used for-loop- 

let arrays = [2.0,4.0,5.0,7.0]
var arraySquar: [Double] = []
for value in arrays {
  arraySquar.append(value*value)
}
// [4.0, 16.0, 25.0, 49.0]

Now With map
let arrays = [2.0,4.0,5.0,7.0]

let arraySquar= arrays .map {$0 * $0}

// [4.0, 16.0, 25.0, 49.0]

let scores = [0,28,124]
let words = scores.map { NumberFormatter.localizedString(from: $0 as NSNumber, number: .spellOut) }
print(words)

// ["zero", "twenty-eight", "one hundred twenty-four"]

Filter :- Use filter to loop over a collection and return an Array containing only those elements that match an include condition and must return a Bool indicating if the item should be included in the result.
x = 3, 4, 10, 17
if x % 2 == 0
then match = 4, 10
Example - 
let values= [3,4,10,21, 22]
let even = digits.filter { $0 % 2 == 0 }
// [4, 10, 22]

Reduce : -  Use reduce to combine all items in a collection to create a single new value.

let items = [2.0,4.0,5.0,7.0]
let total = items.reduce(10.0, +)
// 28.0

This will also work with strings using the + operator to concatenate:

let codes = ["abc","def","ghi"]
let text = codes.reduce("", +)
// "abcdefghi"

The combine argument is a closure so you can also write reduce using the trailing closure syntax:

let names = ["alan","brian","charlie"]
let csv = names.reduce("===") {text, name in "\(text),\(name)"}
// "===,alan,brian,charlie"

FlatMap and CompactMap

Flatmap
Flatmap is used to flatten a collection of collections . But before flattening the collection, we can apply map to each elements.

"Using FlatMap on a sequence with a closure that returns a sequence"
let results = [[5,2,7], [4,8], [9,1,3]]
let allResults = results.flatMap { $0 }
// [5, 2, 7, 4, 8, 9, 1, 3]

let passMarks = results.flatMap { $0.filter { $0 > 5} }
// [7, 8, 9]

let codes = [["abc", "def", "ghi"], ["abc", "def", "ghi"]]
let newCodes = codes.flatMap{ $0.map { $0.uppercased90}}
print(newCodes)

// ["ABC", "DEF", "GHI", "ABC", "DEF", "GHI"]

if newCodes  = codes.flatMap{ $0.uppercased()}
print(newCodes)

// ["A", "B", "C", "D", "E", "F", "G", "H", "I"]

Using FlatMap on an optional:
let input: Int? = Int("8")
let passMark: Int? = input.flatMap { $0 > 5 ? $0 : nil }
// 8
Using CompactMap on a sequence with a closure that returns an optional.

Note that this use of flatMap was renamed to compactMap in Swift 4.1 (Xcode 9.3). It provides a convenient way to strip nil values from an array:
let keys: [String?] = ["Tom", nil, "Peter", nil, "Harry"]
let validNames = keys.compactMap { $0 }
validNames

// ["Tom", "Peter", "Harry"]

let counts = keys.compactMap { $0?.count }
counts
// [3, 5, 5]