Modular State Management: View State

Exercises

1. Another way to isolate code is to move it to its own file and mark part of it private or fileprivate. How does this kind of modularization differ from using an actual Swift module?

2. In this episode we discussed how it was not appropriate to give the name map to the transformation we defined on Store due to the trickiness of reference types. Let’s explore defining map on another type with reference semantics.

   Previously on Point-Free, we defined a Lazy type as a struct around a function that returns a value:

   struct Lazy<A> {
     let run: () -> A
   }
   

   Upgrade this struct to a class so that we can introduce memoization. A call to run should perform the given closure and cache the return value so that any repeat calls to run can immediately return this cached value. It should behave as follows:

   import Foundation
   
   let slow = Lazy<Int> {
     sleep(1)
     return 1
   }
   slow.run() // Returns `1` after a second
   slow.run() // Returns `1` immediately
   

   From here, define map on Lazy:

   extension Lazy {
     func map<B>(_ f: @escaping (A) -> B) -> Lazy<B> {
       fatalError("Unimplemented")
     }
   }
   

   Given our discussion around map on the Store type, is it appropriate to call this function map?

3. Sometimes it can be useful to view into a store so that it removes all access to the underlying state of the store. For example, a “debug” screen for your app could have a UI for listing out every single action in your application as buttons, and tapping the button will send the action to the store. Such a screen doesn’t need any access to the app state.

   Try building such a screen, and provide it view of the store that removes all access to the underlying app state.

4. Write a function that transforms a Store<GlobalValue, GlobalAction> into a Store<GlobalValue, LocalAction>. That is, a function of the following signature:

   extension Store {
     func view<LocalAction>(
       /* what arguments are needed? */
       ) -> Store<Value, LocalAction> {
   
       fatalError("Unimplemented")
     }
   }
   

   What kind of data does the function need to be supplied with in addition to a store? Is this kind of transformation familiar? Does it have a name we’ve used before on Point-Free?