CocoaheadsSKG
Dimitri James Tsiflitzis
In computer science, functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state, and mutable data.
Functional programming is a style of programming that explicitly uses functions that will always return the same result when called with the same input.
or
var evens = [Int]()
for i in 1...10 {
if i % 2 == 0 {
evens.append(i)
}
}
print(evens)
/*
[2, 4, 6, 8, 10]
*/In Swift, filter(_:) is a method on Collection types, such as Swift arrays.
It accepts another function as a parameter. This other function accepts as input a single value from the array, and returns a Bool.
filter
true
true
func isEven(number: Int) -> Bool {
return number % 2 == 0
}
evens = Array(1...10).filter(isEven)
print(evens)
/*
[2, 4, 6, 8, 10]
*//* functions in swift are just named closures */
evens = Array(1...10).filter { (number) in number % 2 == 0 }
print(evens)
/*
[2, 4, 6, 8, 10]
*//* shorthand */
evens = Array(1...10).filter { $0 % 2 == 0 }
print(evens)
/*
[2, 4, 6, 8, 10]
*/Tip: Use the shorthand in simple situations when it will make sense at first glance to a future reader.
For more complicated scenarios you can use named arguments. Compilers have no feelings but humans do.
func arrayFilter<T>(source: [T], predicate:(T) -> Bool) -> [T] {
var result = [T]()
for i in source {
if predicate(i) {
result.append(i)
}
}
return result
}The Collection method map(_:) accepts a single function as a parameter, and in turn, it produces an array of the same length after being applied to each element of the collection.
The return type of the mapped function does not have to be the same type as the collection elements.
Use map to loop over a collection and apply the same operation to each element in the collection.
map
black
yellow
violet
ciel
f(black)
f(yellow)
f(violet)
f(ciel)
map
typealias Years = Int
struct Person {
let name : String
let age : Years
}
let persons = [
Person(name: "John", age: 40),
Person(name: "Paul", age: 74),
Person(name: "George", age: 58),
Person(name: "Ringo", age: 76),
]
let personNames = persons.map { $0.name }
print(personNames)
/*
["John", "Paul", "George", "Ringo"]
*/let values = [2.0,4.0,5.0,7.0]
var squares: [Double] = []
for value in values {
squares.append(value*value)
}
print(squares)
/*
[4.0, 16.0, 25.0, 49.0]
*/let squares = [2.0,4.0,5.0,7.0]
func raiseSquare(number: Double) -> Double {
return number * number
}
squares = squares.map(raiseSquare)
print(squares)
/*
[4.0, 16.0, 25.0, 49.0]
*/let values = [2.0,4.0,5.0,7.0]
let squares = values.map({
(value: Double) -> Double in
return value * value
})
print(squares)
/*
[4.0, 16.0, 25.0, 49.0]
*/let values = [2.0,4.0,5.0,7.0]
let squares = values.map {value in value * value}
print(squares)
/*
[4.0, 16.0, 25.0, 49.0]
*/let values = [2.0,4.0,5.0,7.0]
let squares = values.map { $0 * $0 }
print(squares)
/*
[4.0, 16.0, 25.0, 49.0]
*/The Collection method reduce(_:_:) takes two parameters. The first is a starting value of a generic type Element, and the second is a function that combines a value of type Element with an element in the collection to produce another value of type Element.
Use reduce to combine all items in a collection to create a single new value.
black
yellow
violet
ciel
reduce
let items = [2.0,4.0,5.0,7.0]
let total = items.reduce(10.0,+)
print(total)
/*
28.0
*/Use it to flatten a collection of collections.
let collections = [[5,2,7],nil, [4,8], nil, [9,1,3]]
let flat = collections.flatMap { $0 }
/*
[5, 2, 7, 4, 8, 9, 1, 3]
*/Bonus: Swift ignores optionals for you
Powerful when you transform each subcollection
let collections = [[5,2,7],[4,8],[9,1,3]]
let onlyEven = collections.flatMap {
intArray in intArray.filter { $0 % 2 == 0 }
}
/*
[2, 4, 8]
*/let marks = [4, 5, 8, 2, 9, 7]
let passingTotal = marks.filter{$0 >= 7}.reduce(0,combine: +)
/*
24
*/
let numbers = [20, 17, 35, 4, 12]
let evenSquares = numbers.map{$0 * $0}.filter{$0 % 2 == 0}
/*
[400, 16, 144]
*/Swift is not a purely functional language but it allows you to be flexible and combine styles.
You can get started in your Model or ViewModel layer to get a feel for the lay of the land.
For your UI's checkout RxSwift. Reactive programming is an example of a functional programming, like, approach for UI development.
Your code will be easier to test when isolated into modular functions that are free from side effects. <~~ Famous Last Words