Describe prefix/infix functions and record field accessors in Chapter 3

exercises/chapter3/test/no-peeking/Solutions.purs

@@ -12,6 +12,10 @@ findEntryByStreet streetName = filter filterEntry >>> head
   filterEntry :: Entry -> Boolean
   filterEntry e = e.address.street == streetName
 
+-- Example alternative implementation using property accessor and composition
+findEntryByStreet' :: String -> AddressBook -> Maybe Entry
+findEntryByStreet' streetName = filter (_.address.street >>> ((==) streetName)) >>> head
+
 isInBook :: String -> String -> AddressBook -> Boolean
 isInBook firstName lastName book = not null $ filter filterEntry book
   where

text/chapter3.md

@@ -479,6 +479,38 @@ This process is called _eta conversion_, and can be used (along with some other
 
 In the case of `insertEntry`, _eta conversion_ has resulted in a very clear definition of our function - "`insertEntry` is just cons on lists". However, it is arguable whether point-free form is better in general.
 
+## Property Accessors
+
+One common pattern is to use a function to access an individual fields (or "properties") of a record. An inline function to extract an `Address` from an `Entry` could be written as:
+
+```haskell
+\entry -> entry.address
+```
+
+PureScript provides an equivalent shorthand, where an underscore is followed by a field name, so the inline function above is equivalent to:
+
+```haskell
+_.address
+```
+
+This works with any number of levels or properties, so a function to extract the city associated with an `Entry` could be written as:
+
+```haskell
+_.address.city
+```
+
+For example:
+
+```text
+> address = { street: "123 Fake St.", city: "Faketown", state: "CA" }
+> entry = { firstName: "John", lastName: "Smith", address: address }
+> _.lastName entry
+"Smith"
+
+> _.address.city entry
+"Faketown"
+```
+
 ## Querying the Address Book
 
 The last function we need to implement for our minimal address book application will look up a person by name and return the correct `Entry`. This will be a nice application of building programs by composing small functions - a key idea from functional programming.
@@ -547,11 +579,23 @@ Note that, just like for top-level declarations, it was not necessary to specify
 
 ## Infix Function Application
 
-In the code for `findEntry` above, we used a different form of function application: the `head` function was applied to the expression `filter filterEntry book` by using the infix `$` symbol.
+Most of the functions discussed so far used _prefix_ function application, where the function name was put _before_ the arguments. For example, when using the `findEntry` function to search an `AddressBook`, one might write:
+
+```text
+> findEntry "John" "Smith" addressBook
+```
+
+However, this chapter has also included examples of _infix_ functions, such as  the `==` function in the definition of `filterEntry`, where the function is put _between_ the arguments. These infix operators are actually defined in the PureScript source as infix aliases for their underlying implementations. For example, `==` is defined as an alias for the prefix `eq` function with the line:
+
+```haskell
+infix 4 eq as ==
+```
+
+Likewise, in the code for `findEntry` above, we used a different form of function application: the `head` function was applied to the expression `filter filterEntry book` by using the infix `$` symbol.
 
 This is equivalent to the usual application `head (filter filterEntry book)`
 
-`($)` is just an alias for a regular function called `apply`, which is defined in the Prelude. It is defined as follows:
+`$` is just an alias for a regular function called `apply`, which is defined in the Prelude. It is defined as follows:
 
 ```haskell
 apply :: forall a b. (a -> b) -> a -> b
@@ -560,20 +604,60 @@ apply f x = f x
 infixr 0 apply as $
 ```
 
-So `apply` takes a function and a value and applies the function to the value. The `infixr` keyword is used to define `($)` as an alias for `apply`.
+So `apply` takes a function and a value and applies the function to the value. The `infixr` keyword is used to define `$` as an alias for `apply`.
 
 But why would we want to use `$` instead of regular function application? The reason is that `$` is a right-associative, low precedence operator. This means that `$` allows us to remove sets of parentheses for deeply-nested applications.
 
 For example, the following nested function application, which finds the street in the address of an employee's boss:
 
 ```haskell
-street (address (boss employee))
+_.street (_.address (_.boss employee))
 ```
 
 becomes (arguably) easier to read when expressed using `$`:
 
 ```haskell
-street $ address $ boss employee
+_.street $ _.address $ _.boss employee
+```
+
+Note that neither of the above examples is idiomatic PureScript. Real-world code is more likely to express this as:
+```haskell
+(boss employee).address.street
+```
+or
+```haskell
+_.boss.address.street employee
+```
+
+There are situations where putting a prefix function in an infix position as an operator leads to more readable code. One example is the `mod` function:
+```text
+> mod 8 3
+2
+```
+This is fine, but doesn't line up with common usage. Wrapping a prefix function in backticks (\`) lets you use a prefix function in infix position as an operator, e.g.,
+```text
+> 8 `mod` 3
+2
+```
+Likewise, wrapping an operator in parentheses lets you use it as a function in prefix position:
+```text
+> 8 + 3
+11
+
+> (+) 8 3
+11
+```
+This allows for compact definitions of curried (or partially applied) functions based on infix operator functions, such as the `add2` function below:
+```text
+> add2 = (+) 2
+> add2 4
+6
+```
+Alternatively, operators can be partially applied by surrounding them with parentheses and using `_` as an operand:
+```text
+> add3 = (3 + _)
+> add3 2
+5
 ```
 
 ## Function Composition
@@ -612,6 +696,7 @@ I will let you make your own decision which definition is easier to understand,
 
  1. (Easy) Test your understanding of the `findEntry` function by writing down the types of each of its major subexpressions. For example, the type of the `head` function as used is specialized to `AddressBook -> Maybe Entry`. _Note_: There is no test for this exercise.
  1. (Medium) Write a function `findEntryByStreet :: String -> AddressBook -> Maybe Entry` which looks up an `Entry` given a street address. _Hint_ reusing the existing code in `findEntry`. Test your function in PSCi and by running `spago test`.
+ 1. (Medium) Rewrite `findEntryByStreet` to replace `filterEntry` with the composition (using `<<<` or `>>>`) of: a property accessor (using the `_.` notation); and a function that tests whether its given string argument is equal to the given street address.
  1. (Medium) Write a function `isInBook` which tests whether a name appears in a `AddressBook`, returning a Boolean value. _Hint_: Use PSCi to find the type of the `Data.List.null` function, which tests whether a list is empty or not.
  1. (Difficult) Write a function `removeDuplicates` which removes "duplicate" address book entries. We'll consider entries duplicated if they share the same first and last names, while ignoring `address` fields. _Hint_: Use PSCi to find the type of the `Data.List.nubBy` function, which removes duplicate elements from a list based on an equality predicate. Note that the first element in each set of duplicates (closest to list head) is the one that is kept.