Upgrade to Pro — share decks privately, control downloads, hide ads and more …

State Driven Development: Enumerating the reaso...

State Driven Development: Enumerating the reasons why Enums are Awesome!

If you've ever been surprised or delighted by enum in Swift, or have ever regretted typing @property BOOL in Objective-C, then this talk is for you!

Boolean state variables are the enemy of clean code. It starts with one variable to represent if something is connected or not. But there will probably be a dozen or more methods that need to check that variable, so now your code is dependent on it. New variables will emerge – with conflicting reasons for why each one should be set to true or false. The web of state gets tangled very quickly.

Keeping code clean is just more fun with enums. Enum cases can contain associated values, so your state variables are always available in the context where they are most relevant. And because enums can have method implementations and protocol conformances in Swift, all of your state checking and branching can happen right there in the enum itself!

This is a talk that everyone can learn something from. You should read the Swift language chapter on enums for how they work, and come to this talk for inspiration on where and when to use them!

Conrad Stoll

August 27, 2018
Tweet

More Decks by Conrad Stoll

Other Decks in Programming

Transcript

  1. How often exactly? // Regex for boolean state // Match

    Bool typed vars that aren't computed properties var.*:.*Bool(\n|.*=.*) var.*=\s?(true|false)
  2. var active : Bool var contentLoaded : Bool var dataLoaded

    : Bool var editing : Bool var enabled : Bool var expanded : Bool var handlingTouches : Bool var hasTakenUserAction : Bool var isCompleted : Bool var isRunning : Bool var lastTouchedButtonSide : Bool var lastTouchedRightSide : Bool var notified : Bool var previewEnded : Bool var saved : Bool var started : Bool
  3. One Variable var hasLoggedIn : Bool = false func startWorkout()

    { guard hasLoggedIn else { return } // ... }
  4. Two Variables var hasLoggedIn : Bool = false var workoutInProgress

    : Bool = false func startWorkout() { guard hasLoggedIn && workoutInProgress == false else { return } workoutInProgress = true // ... }
  5. The Tangled Web of State var hasLoggedIn : Bool =

    false var workoutInProgress : Bool = false var savingWorkout : Bool = false func stopWorkout() { workoutInProgress = false savingWorkout = true saveWorkout { (success) in self.savingWorkout = false } }
  6. The Tangled Web of State var hasLoggedIn : Bool =

    false var workoutInProgress : Bool = false var savingWorkout : Bool = false func startWorkout() { guard hasLoggedIn && workoutInProgress == false && !savingWorkout else { return } workoutInProgress = true // ... }
  7. The user CANNOT start a workout: - Hasn't logged into

    the app yet - In the middle of a workout - Saving the last workout
  8. Valid Boolean States User Not Logged In, No Workout, Not

    Saving User Logged In, No Workout, Not Saving User Logged In, Workout In Progress, Workout Not Saving User Logged In, No Workout, Workout Is Saving var hasLoggedIn : Bool var workoutInProgress : Bool var savingWorkout : Bool
  9. Invalid Boolean States User Not Logged In, Workout In Progress,

    Not Saving User Not Logged In, Workout In Progress, Workout Is Saving User Not Logged In, No Workout, Workout Is Saving User Logged In, Workout In Progress, Workout Is Saving var hasLoggedIn : Bool var workoutInProgress : Bool var savingWorkout : Bool
  10. - Hasn't logged into the app yet - In the

    middle of a workout - Saving the last workout - Ready to start workout
  11. Converting to Enums var hasLoggedIn : Bool = false var

    workoutInProgress : Bool = false var savingWorkout : Bool = false func startWorkout() { guard hasLoggedIn && workoutInProgress == false && !savingWorkout else { return } workoutInProgress = true // ... }
  12. var lifecycle : WorkoutApplicationLifecycle = .notLoggedIn func startWorkout() { //

    Equivalent guard .readyToStart == lifecycle else { return } // Pattern Matching guard case .readyToStart = lifecycle else { return } lifecycle = .workoutInProgress // ... }
  13. enum WorkoutApplicationLifecycle { case notLoggedIn case workoutInProgress case savingLastWorkout case

    readyToStart var canStartWorkout : Bool { get { switch self { case .notLoggedIn: return false case .workoutInProgress: return false case .savingLastWorkout: return false case .readyToStart: return true } } } }
  14. Simplified for multiple cases enum WorkoutApplicationLifecycle { case notLoggedIn case

    workoutInProgress case savingLastWorkout case readyToStart var canStartWorkout : Bool { get { switch self { case .notLoggedIn, .workoutInProgress, .savingLastWorkout: return false case .readyToStart: return true } } } }
  15. Simplified using fallthrough enum WorkoutApplicationLifecycle { case notLoggedIn case workoutInProgress

    case savingLastWorkout case readyToStart var canStartWorkout : Bool { get { switch self { case .notLoggedIn: fallthrough case .workoutInProgress: fallthrough case .savingLastWorkout: return false case .readyToStart: return true } } } }
  16. default Danger! enum WorkoutApplicationLifecycle { case notLoggedIn case workoutInProgress case

    savingLastWorkout case readyToStart var canStartWorkout : Bool { get { switch self { case .readyToStart: return true default: return false } } } }
  17. Enums describing the behavior var lifecycle : WorkoutApplicationLifecycle = .notLoggedIn

    func startWorkout() { guard lifecycle.canStartWorkout else { return } lifecycle = .workoutInProgress // ... }
  18. Enums describing the behavior var lifecycle : WorkoutApplicationLifecycle = .notLoggedIn

    func stopWorkout() { lifecycle = .savingLastWorkout saveWorkout { (success) in self.lifecycle = .readyToStart } }
  19. State Driven Development enum WorkoutApplicationLifecycle { case notLoggedIn case workoutInProgress

    case savingLastWorkout case readyToStart var canStartWorkout : Bool var actionTitle : String var backgroundColor : UIColor var barButtonItems : [UIBarButtonItem] }
  20. Title for Buttons enum WorkoutApplicationLifecycle { // ... var actionTitle

    : Bool { get { switch self { case .notLoggedIn: return "Sign In" case .workoutInProgress: return "End Workout" case .savingLastWorkout: return "Saving Workout" case .readyToStart: return "Start Workout" } } } }
  21. Actions for Buttons enum WorkoutApplicationLifecycle { // ... func actionTaken(from

    viewController : WorkoutViewController) { switch self { case .notLoggedIn: viewController.login() case .workoutInProgress: viewController.stopWorkout() viewController.saveWorkout() case .savingLastWorkout: break case .readyToStart: viewController.startWorkout() } } }
  22. Adding Features enum WorkoutApplicationLifecycle { // ... case restoringWorkout var

    canStartWorkout : Bool { case .restoringWorkout: return false } var actionTitle : Bool { case .restoringWorkout: return "Restoring Workout" } func actionTaken(from viewController : WorkoutViewController) { case .restoringWorkout: break } }
  23. Accessing Associated Values switch self { case .workoutInProgress(let workout): break

    } if case let .workoutInProgress(workout) = lifecycle { // ... }
  24. if case .workoutInProgress = lifecycle { } if case let

    .workoutInProgress(_) = lifecycle { // ... } if case let .workoutInProgress(current: workout) = lifecycle { // ... } if case .workoutInProgress(let workout) = lifecycle { // ... } if case let .workoutInProgress(workout, user) = lifecycle { // ... }
  25. switch self { case .workoutInProgress: // ... case .workoutInProgress(_): //

    ... case let .workoutInProgress(current: workout): // ... case let .workoutInProgress(workout, user): // ... case .workoutInProgress(let workout): // ... }
  26. Recommended Syntax if case let .workoutInProgress(current: workout) = lifecycle {

    // ... } switch self { case let .workoutInProgress(current: workout): // ... }
  27. Using Associated Values enum WorkoutApplicationLifecycle { // ... case workoutInProgress(current:

    Workout) func actionTaken(from viewController : WorkoutViewController) { switch self { case let .workoutInProgress(current: workout): viewController.stopWorkout() viewController.saveWorkout(current: workout) } } }
  28. Using Associated Values enum WorkoutApplicationLifecycle { // ... case workoutInProgress(current:

    Workout) var navigationTitle : String { switch self { case let .workoutInProgress(current: workout): return workout.type.activityName } } }
  29. Setting Associated Values var lifecycle : WorkoutApplicationLifecycle = .notLoggedIn func

    startWorkout() { guard lifecycle.canStartWorkout else { return } var newWorkout : Workout // ... lifecycle = .workoutInProgress(current: workout) }
  30. enum TableViewCellConfiguration { case simpleCell(title : String) case detailedCell(title :

    String, description : String) case imageCell(title : String, image : UIImage) case accessoryCell(title : String, image : UIImage, accessory : UITableViewCellAccessoryType) var titleText : String var descriptionText : String? var image : UIImage? var accessoryType : UITableViewCellAccessoryType }
  31. enum TableViewCellConfiguration { case workoutCell(workout : Workout) case userProfileCell(loggedIn :

    User) case exerciseCell(exercise : Exercise) case trainingPlanCell(plan : TrainingPlan) var titleText : String var descriptionText : String? var image : UIImage? var accessoryType : UITableViewCellAccessoryType }
  32. class CustomTableViewCell : UITableViewCell { @IBOutlet weak var titleLabel :

    UILabel! @IBOutlet weak var descriptionLabel : UILabel? @IBOutlet weak var imageView : UIImageView? func setup(as configuration : TableViewCellConfiguration) { titleLabel.text = configuration.titleText descriptionLabel?.text = configuration.descriptionText imageView?.image = configuration.image accessoryType = configuration.accessoryType } }
  33. Cell Configuration func tableView(_ tableView: UITableView, cellForItemAt indexPath: IndexPath) ->

    UITableViewCell { let cell = tableView.dequeueReusableCell (withReuseIdentifier: reuseIdentifier, for: indexPath) as! CustomTableViewCell let exercise = exercises[indexPath.row] cell.setup(as: .exerciseCell(exercise: exercise)) return cell }
  34. View Controller Mode Methods - viewSetupForTransitionToState - cancelButtonAction - editButtonAction

    - saveButtonAction - barButtonSetupForTransitionToState - leftBarButtonItems - rightBarButtonItems
  35. View Controller Mode Methods - didSelectRowAtIndexPath - contentSelectionAction - shouldHighlightCellAction

    - shouldHandleLongPressGestureAction - dragInteractionEnabled - numberOfSections - numberOfRowsInSection
  36. if activityType == .running || activityType == .walking { gpsProvider.start()

    } if activityType == .running || activityType == .walking { gpsProvider.stop() }
  37. if activityType == .running || activityType == .walking || activityType

    == .hiking { gpsProvider.start() } if activityType == .running || activityType == .walking { gpsProvider.stop() }
  38. Result1 Success, Failure enum Result<Value> { case success(Value) case failure(Error)

    } 1 https://www.swiftbysundell.com/posts/the-power-of-result-types-in-swift
  39. Confetti Moments public enum ConfettiMoment { // Color Confetti case

    confettiMMF case confettiMFP case confetti ! // Emoji Confetti case " // Custom Confetti case customColors(colors : [UIColor], name : String) case customImages(images : [UIImage], name : String) }
  40. Protocols extension ConfettiMoment : CustomStringConvertible { public var description: String

    { get { switch self { case . ! : return " ! " case .confettiMMF: return "MMF" case .confettiMFP: return "MFP" case .confetti " : return " " case .customColors(_, let name): return name case .customImages(_, let name): return name } } } }
  41. Raw Values enum DefaultKeys : String { case loggedInUserId case

    selectedActivityType } print(DefaultKeys.selectedActivityType.rawValue) selectedActivityType
  42. Raw Values enum DefaultKeys : String { case loggedInUserId case

    selectedActivityType = "SelectedActivityTypeDefaultKey" } print(DefaultKeys.selectedActivityType.rawValue) SelectedActivityTypeDefaultKey
  43. RawRepresentable enum ApplicationTheme { case defaultLight case darkMode case blueberry

    case eggplant case mustard case broccoli } struct Theme : Equatable { let name : String let background : UIColor let cell : UIColor let tint : UIColor let foreground : UIColor let statusBar : UIStatusBarStyle }
  44. RawRepresentable enum ApplicationTheme { case defaultLight(theme : Theme) case darkMode(theme

    : Theme) case blueberry(theme : Theme) case eggplant(theme : Theme) case mustard(theme : Theme) case broccoli(theme : Theme) }
  45. RawRepresentable extension ApplicationTheme : RawRepresentable { typealias RawValue = Theme

    init?(rawValue: Theme) { // ... } var rawValue: Theme { // ... } } print(ApplicationTheme.broccoli.rawValue.name) Brocolli
  46. CaseIterable enum WorkoutApplicationLifecycle : CaseIterable { case notLoggedIn case workoutInProgress

    case savingLastWorkout case readyToStart } WorkoutApplicationLifecycle.allCases [notLoggedIn, workoutInProgress, savingLastWorkout, readyToStart]
  47. Custom CaseIterable enum WorkoutApplicationLifecycle { case notLoggedIn case workoutInProgress(current :

    Workout) case savingLastWorkout case readyToStart } extension WorkoutApplicationLifecycle : CaseIterable { static var allCases: [WorkoutApplicationLifecycle] { return [.notLoggedIn, .savingLastWorkout, .readyToStart] + WorkoutActivityType.allCases.map(.workoutInProgress) } }
  48. All the Confetti Moments extension ConfettiMoment : CaseIterable { static

    var allCases: [ConfettiMoment] { return [. ! , .confettiMMF, .confettiMFP, .confetti ] } }
  49. All the Themes enum ApplicationTheme : CaseIterable { case defaultLight

    case darkMode case blueberry case eggplant case mustard case broccoli } ApplicationTheme.allCases [.defaultLight, .darkMode, .blueberry, .eggplant, .mustard, .broccoli]
  50. Additional Resources - Enum Driven Table Views34 - Pattern Matching

    in Swift5 5 http://alisoftware.github.io/swift/pattern-matching/2016/03/27/pattern-matching-1/ 4 https://www.raywenderlich.com/5542-enum-driven-tableview-development 3 https://www.natashatherobot.com/swift-enums-tableviews/
  51. Additional Resources - Enums and Optionals6 - Writing Self Documenting

    Swift Code7 - Code Encapsulation in Swift8 - Enumerations9 9 https://ericasadun.com/2015/05/26/swift-the-hall-of-the-dwarven-enumeration-king/#more-1529 8 https://www.swiftbysundell.com/posts/code-encapsulation-in-swift 7 https://www.swiftbysundell.com/posts/writing-self-documenting-swift-code 6 http://khanlou.com/2018/04/enums-and-optionals/