Finished doc for filter

Author: Bob Lee

course/functional-programming/filter.md

@@ -8,6 +8,8 @@ How to get things done with one line of code?
 > **Note:** Most people use Swift functions without knowing the behind implementation
 
 ### Imperative/Non-functional
+Let's attempt to grab even numbers using a non-functional approach.
+
 ```swift
 // Get even numbers
 var evens = [Int]()
@@ -19,16 +21,20 @@ for i in 1...10 {
 }
 ```
 
+It certainly works. But, you know what I'm about to say.
+
 ### Declarative/Functional
-You may execute the task above using the built-in `filter` method by the `Array` struct. However, you will discover how things work throughout this lesson. If you are stuck, don't you worry. I will walk you through.
+If you remember correct, `Array` is just a `struct` and it contains built-in methods. `filter` is one of them. Let us utilize the `filter` function to get things done. You don't have to understand what goes under the hood at this point, but you will by creating our own custom `filter` function.
 
 ```swift
 Array(1...10).filter { (number) in number % 2 == 0 }
 Array(1...10).filter { $0 % 2 == 0 }
 ```
 
+Let us find out what the heck is going on. Don't you worry. As long as you are comfortable with closures and generics, you will get through with me.
+
 ### Become an A Student
-My mom used to like when I handed my grade sheet filled with "A"s. Let's find out how to only get "A" letters to please my mom.
+My mom used to love (still do since I'm in college) when I handed my grade sheet filled with "A"s. Let's find out how to only get "A" letters to please my mom.
 
 ```swift
 let recentGrade = ["A", "A", "A", "A", "B", "D"] // It can be any data
@@ -56,6 +62,7 @@ The code above tells you the steps how you filtered `recentGrade`. This is long,
 From now on, you might find it difficult. Bear with me. First of all, let's create a function either returns `true` or `false` based on the parameter.
 
 Create closure block that returns true/false
+
 ```swift
 var isMomHappy: (String) -> Bool = { grade in return grade == "A" }
 isMomHappy = { $0 == "A" }
@@ -64,6 +71,8 @@ isMomHappy("A") // true
 isMomHappy("B") // true
 ```
 
+Create a function that take the closure block whose type is `(String) -> Bool`. I will call the parameter as `operation`.
+
 ```swift
 func simpleStringFilter(grades: [String], operation: (String) -> Bool) {
   var happyGrade: [String] = []
@@ -75,6 +84,16 @@ func simpleStringFilter(grades: [String], operation: (String) -> Bool) {
 }
 ```
 
+Within the `simpleStringFilter`, the `operation` closure is executed. If `operation` returns `true`, append the grade to `happyGrade`.
+
+Let's execute `simpleStringFilter`.  The `isMomHappy` closure is passed  to the `operation` parameter.
+
+```swift
+simpleStringFilter(grades: recentGrade, operation: isMomHappy) // ["A", ...]
+```
+
+The entire function may also return `[String]`
+
 ```swift
 func stringFilter(grades: [String], operation: (String) -> Bool) -> [String] {
   var happyGrade: [String] = []
@@ -87,55 +106,76 @@ func stringFilter(grades: [String], operation: (String) -> Bool) -> [String] {
 }
 ```
 
-### Generic Filter
+Execute `stringFilter`.
+
+```swift
+let myGrade = ["A", "A", "A", "A", "B", "D"]
+let happyGrade = stringFilter(grades: myGrade, operation: isMomHappy)
+happyGrade // ["A", ...]
+```
+
+### Pass Closure Directly
+So far, you've passed the closure block indirectly to the `operation` parameter using `isMomHappy`. However, you may directly enter a closure block. The syntax may look strange but I'm sure you are comfortable with closures at this point.
+
 ```swift
-func bobFilter<Bob>(array: [Bob], logic: (Bob) -> Bool) -> [Bob] {
+stringFilter(grades: myGrade, operation: { element in return element == "A" })
+stringFilter(grades: myGrade, operation: { $0 == "A" })
+```
+
+### Generic Function
+If you remember from Chapter 1, intro to generics, it doesn't make sense to create a distinct function just for `String` only. Let us utilize the Swift generics.
+
+```swift
+func bobFilter<Bob>(array: [Bob], operation: (Bob) -> Bool) -> [Bob] {
   var result: [Bob] = []
   for element in array {
-    if logic(element) {
+    if operation(element) {
       result.append(element)
     }
   }
   return result
 }
 ```
 
+The placeholder type of `bobFilter` is `Bob` which should be defined later. Usually, we use `T` instead.
+
 ```swift
-func myFilter<T>(array: [T], logic: (T) -> Bool) -> [T] {
+func myFilter<T>(array: [T], operation: (T) -> Bool) -> [T] {
   var result: [T] = []
   for element in array {
-    if logic(element) {
+    if operation(element) {
       result.append(element)
     }
   }
   return result
 }
 ```
 
-```swift
-let myGrade = ["A", "A", "A", "A", "B", "D"]
-let lovelyGrade = stringFilter(grades: myGrade, operation: isMomHappy)
-```
-
-```swift
-stringFilter(grades: myGrade, operation: { $0 == "A" })
-```
+### Examples
+So, let us find out how `myFilter` can be used.
 
+#### Ex 1) Filter Numbers
 ```swift
-let AStudent = myFilter(array: Array(1...100), logic: { $0 >= 93 && $0 <= 100 })
+let AStudent = myFilter(array: Array(1...100), operation: { $0 >= 93 && $0 <= 100 })
 print(AStudent) // [93, 94, 95, ... 100]
 ```
 
+#### Ex 2) Vote Counting
 ```swift
 let answer = [true, false, true, false, false, false, false]
-let trueAnswer = myFilter(array: answer, logic: { $0 == true })
+let trueAnswer = myFilter(array: answer, operation: { $0 == true })
 ```
 
+The rest is history. You can use your imagination from now on.
+
+You may also utilize trailing closures to beautify.
+
 ```swift
-// Trailing Closure
 let falseAnswer = myFilter(array: answer) { $0 == false }
 ```
 
+### Built-in Swift Filter
+As I mentioned earlier, `Array<T>` comes with its own `filter`. Let us utilize. We don't have to reinvent.
 
 ```swift
 let zeroToHund = Array(1...100)
@@ -144,6 +184,7 @@ zeroToHund.filter{ $0 % 2 == 0 }.filter { $0 <= 50 }
 ```
 
 ### The Purest Form
+The built-in `filter` may look something like this. Since you have not taken generics protocols in the following chapter and Advanced Swift, you may be confused with `Element`. It's the type of an array for now.  
 
 ```swift
 extension Array {
@@ -159,14 +200,19 @@ extension Array {
 }
 ```
 
-Test it out.
+Let us test it out.
 
 ```swift
 let result = Array(1...100).myFilter { $0 % 2 == 0 }
 ```
 
 ### Source Code
+[6002_filter.playground]()
 
 ### Resources
+[Intro to Functional Programming](https://blog.bobthedeveloper.io/intro-to-swift-functional-programming-with-bob-9c503ca14f13)
 
 ## Conclusion
+Congratulations. You've learned what goes under the hood of `filter`, one of the most common functions. From now on, you understand what it means to pass a closure block at the end and you've learned how the closure block is used within the main function. This principle applies in every other major functions we will take a look at. Along with generics, it allows reusability, thus scalability in your code base.
+
+At the end of the lesson, I've mentioned `Element` of an array. I don't expect you to know what it is. However, in the last chapter of this course, you will learn the behind scene by understanding the statement, "Swift is a protocol oriented programming language". Let's continue. 

course/functional-programming/intro-functional-paradigm.md

@@ -97,4 +97,4 @@ A functional paradigm ensures no mutability or no change in state when used.
 ## Conclusion
 Now, I've demystified the concept of "Functional Programming" for you. Again, based on my simplest definition, it's nothing more than using functions to solve problems.
 
-In the Swift Foundation library built by Apple Engineers there are dozens of useful functions for us developers may use. However, as a developer, we've got to know the behind scene of each function. In the rest of the chapter, you will learn how those functions are created and you will be able to produce on your custom functions depending on your need. From now on, the lesson can get rough and tough, again, make sure you completely understand closures and generics before you jump in.  
+In the Swift Foundation library built by Apple Engineers, there are dozens of useful functions for us developers may use. However, as a developer, we've got to know the behind scene of each function. In the rest of the chapter, you will learn how those functions are created and you will be able to produce on your custom functions depending on your need. From now on, the lesson can get rough and tough, again, make sure you completely understand closures and generics before you jump in.  

source-code/6000_functional_programming/.DS_Store

@@ -57,6 +57,10 @@ func simpleStringFilter(grades: [String], operation: (String) -> Bool) {
   }
 }
 
+//: Execute the function by passing `isMomHappy`
+simpleStringFilter(grades: recentGrade, operation: isMomHappy) // ["A", ...]
+
+
 func stringFilter(grades: [String], operation: (String) -> Bool) -> [String] {
   var happyGrade: [String] = []
   for grade in grades {
@@ -67,8 +71,8 @@ func stringFilter(grades: [String], operation: (String) -> Bool) -> [String] {
   return happyGrade
 }
 
-
 let myGrade = ["A", "A", "A", "A", "B", "D"]
+stringFilter(grades: myGrade, operation: isMomHappy)
 
 //: Pass the closure block indirectly
 let lovelyGrade = stringFilter(grades: myGrade, operation: isMomHappy)