O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Swift 3 Functional Programming

Book Description

Bring the power of Swift functional programming to iOS, Web, macOS, watchOS and tvOS application development and build clean, smart, scalable and reliable applications

About This Book

  • Written for Swift 3 -Developers Preview version, this is a comprehensive guide that introduces iOS and OS X developers to the all-new world of functional programming that has so far been alien to them
  • Learn about first-class functions and how imperative-style patterns can be converted into functional code using some simple techniques
  • The book will get you familiar with using functional programming alongside existing OOP techniques so you can get the best of both worlds and develop clean, robust code

Who This Book Is For

The book is for developers with a basic knowledge of Swift programming aiming to incorporate functional programming paradigms in their day-to-day application development

What You Will Learn

  • First-class, higher-order, and pure functions
  • Closures and capturing values
  • Custom operators, recursion, and memoization
  • Value and reference types in Swift
  • Enumerations, algebraic data types, patterns, and pattern matching
  • Generics and associated type protocols
  • Higher-order functions such as map, flatMap filter, and reduce
  • Dealing with optionals, fmap, and apply for multiple functional mapping
  • Functional data structures such as Semigroup, Monoid, Binary Search Tree, Linked List, Stack, and Lazy List
  • Immutability, copy constructors, and lenses
  • Combining FP paradigms with OOP, FRP, and POP in your day-to-day development activities
  • Developing a backend application with Swift
  • Developing an iOS application with FP, OOP, FRP, and POP paradigms

In Detail

This book is based on Swift 3 Developer preview version and aims at simplifying the functional programming (FP) paradigms making it easily usable, by showing you how to solve many of your day-to-day development problems.

Whether you are new to functional programming and Swift or experienced, this book will strengthen the skills you need to design and develop high-quality, scalable, and efficient applications.

The book starts with functional programming concepts, the basics of Swift 3, and essential concepts such as functions, closures, optionals, enumerations, immutability, and generics in detail with coding examples.

Furthermore, this book introduces more advanced topics such as function composition, monads, functors, applicative functors, memoization, lenses, algebraic data types, functional data structures, functional reactive programming (FRP), protocol-oriented programming (POP) and mixing object-oriented programming (OOP) with functional programming (FP) paradigms.

Finally, this book provides a working code example of a front-end application developed with these techniques and its corresponding back-end application developed with Swift.

Style and approach

This is an easy-to-follow guide full of hands-on coding examples of real-world applications. Each topic is explained sequentially and placed in context, and for the more inquisitive, there are more details of the concepts used. It introduces the Swift language basics and functional programming techniques in simple, non-mathematical vocabulary with examples in Swift.

Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the code file.

Table of Contents

  1. Swift 3 Functional Programming
    1. Swift 3 Functional Programming
    2. Credits
    3. About the Author
    4. About the Reviewer
    5. www.PacktPub.com
      1. Why subscribe?
      2. Free access for Packt account holders
    6. Preface
      1. What this book covers
      2. What you need for this book
      3. Who this book is for
      4. Conventions
      5. Reader feedback
      6. Customer support
        1. Downloading the example code
        2. Downloading the color images of this book
        3. Errata
        4. Piracy
        5. Questions
    7. 1. Getting Started with Functional Programming in Swift
      1. Why functional programming matters?
      2. What is functional programming?
      3. The Swift programming language
        1. Swift features
          1. Modern syntax
          2. Type safety and type inference
          3. Immutability
          4. Stateless programming
          5. First-class functions
          6. Higher-order functions
          7. Pattern matching
          8. Generics
          9. Closures
          10. Subscripts
          11. Optional chaining
          12. Extensions
          13. Objective-C and Swift bridging headers
          14. Automatic Reference Counting
          15. REPL and Playground
        2. Language basics
          1. Type safety and type inference
          2. Type annotation
          3. Type aliases
          4. Immutability
          5. Tuples
          6. Optionals
          7. Basic operators
          8. Strings and characters
            1. Immutability
            2. String literals
            3. Empty Strings
            4. Concatenating strings and characters
            5. String interpolation
            6. String comparison
          9. Collections
          10. Control flows
            1. for loops
            2. while loops
            3. stride
            4. if
            5. switch
            6. guard
          11. Functions
          12. Closures
          13. Map, filter, and reduce
            1. Map
            2. Filter
            3. Reduce
          14. Enumerations
          15. Generics
          16. Classes and structures
            1. Classes versus structures
            2. Choosing between classes and structures
            3. Identity operators
          17. Properties
            1. Property observers
          18. Methods
          19. Subscripts
          20. Inheritance
          21. Initialization
          22. Deinitialization
          23. Automatic Reference Counting
          24. Optionals and optional chaining
          25. Error handling
          26. Type casting
          27. Any and AnyObject
          28. Nested types
          29. Extensions
          30. Protocols
            1. Protocols as types
            2. Protocol extensions
          31. Access control
      4. Summary
    8. 2. Functions and Closures
      1. What is a function?
      2. The general syntax of functions and methods
        1. Best practices in function definition
        2. Calling functions
      3. Defining and using function parameters
      4. Defining and using variadic functions
      5. Returning values from functions
      6. Pure functions
      7. Function types
      8. Defining and using nested functions
      9. First-class functions
      10. Higher-order functions
      11. Function composition
        1. Custom operators
          1. Allowed operators
          2. Custom operator definition
        2. A composed function with a custom operator
      12. Closures
        1. Closure syntax
        2. Capturing values
      13. Function currying
      14. Recursion
        1. Tail recursion
      15. Memoization
      16. Summary
    9. 3. Types and Type casting
      1. Value versus reference types
        1. Value and reference type constants
        2. Mixing value and reference types
        3. Copying
        4. Copying reference types
        5. Value type characteristics
          1. Behavior
          2. Isolation
          3. Interchangeability
          4. Testability
          5. Threats
        6. Using value and reference types
      2. Equality versus identity
      3. Equatable and Comparable
      4. Type checking and casting
      5. Summary
    10. 4. Enumerations and Pattern Matching
      1. Defining enumerations
      2. Associated values
      3. Raw values
      4. Algebraic data types
        1. Simple types
        2. Composite types
        3. Composite type with variants
        4. The algebra of data types
      5. Pattern matching
      6. Patterns and pattern matching
        1. The wildcard pattern
        2. The value-binding pattern
        3. The identifier pattern
        4. The tuple pattern
        5. The enumeration case pattern
        6. The optional pattern
        7. Type casting patterns
        8. The expression pattern
      7. Summary
    11. 5. Generics and Associated Type Protocols
      1. What are generics and what kind of problems do they solve?
      2. Type constraints
        1. Where clauses
      3. Generic data structures
      4. Associated type protocols
      5. Extending generic types
      6. Subclassing generic classes
      7. Summary
    12. 6. Map, Filter, and Reduce
      1. Functor
      2. Applicative Functor
      3. Monad
      4. Map
      5. FlatMap and flatten
      6. Filter
      7. Reduce
        1. The map function in terms of reduce
        2. The filter function in terms of reduce
        3. The flatMap function in terms of reduce
        4. The flatten function in terms of reduce
      8. Apply
      9. Join
      10. Chaining higher-order functions
      11. Zip
      12. Practical examples
        1. Sum of an array
        2. Product of an array
        3. Removing nil values from an array
        4. Removing duplicates in an array
        5. Partitioning an array
      13. Summary
    13. 7. Dealing with Optionals
      1. Optional types
      2. Unwrapping optionals
        1. Force unwrapping
        2. nil checking
        3. Optional binding
      3. Guard
      4. Implicitly unwrapped optionals
      5. Error handling to avoid optionals
        1. try!
        2. try?
      6. Nil-coalescing
      7. Optional chaining
      8. Dealing with optionals functionally
        1. Optional mapping
        2. Multiple optional value mapping
      9. Summary
    14. 8. Functional Data Structures
      1. Semigroup
      2. Monoid
      3. Trees
        1. Contains
        2. Binary Search Tree
          1. Contains
          2. Size
          3. Elements
          4. Empty
      4. Lists
        1. Empty LinkedList
        2. Cons
        3. Contains
        4. Size
        5. Elements
        6. isEmpty
        7. map, filter, and reduce
      5. Stacks
      6. Lazy list
      7. Summary
    15. 9. Importance of Immutability
      1. Immutability
      2. Immutable variables
        1. Weak versus strong immutability
      3. Reference types versus value types
      4. The benefits of immutability
        1. Thread safety
        2. Referential transparency
        3. Low coupling
        4. Avoiding temporal coupling
        5. Avoiding identity mutability
        6. Failure atomicity
        7. Parallelization
        8. Exception handling and error management
        9. Caching
        10. State comparison
        11. Compiler optimization
      5. Cases for mutability
      6. An example
        1. Side-effects and unintended consequences
        2. Testability
      7. Copy constructors and lenses
        1. Copy constructor
        2. Lens
          1. Lens composition
      8. Summary
    16. 10. The Best of Both Worlds – Combining FP Paradigms with OOP
      1. OOP paradigms
        1. Objects
        2. Classes
        3. Inheritance
          1. Overriding
          2. Design constraints
            1. Singleness
            2. Static
            3. Visibility
            4. Composite reuse
          3. Issues and alternatives
          4. When to inherit
        4. Polymorphism
        5. Dynamic binding
      2. OOP design principles
        1. SRP
          1. The FP counterpart
        2. OCP
          1. The FP counterpart
        3. LSP
          1. The FP counterpart
        4. ISP
          1. The FP counterpart
        5. DIP
          1. The FP counterpart
        6. DDD
          1. Concepts
          2. Premise
          3. Building blocks
            1. Aggregate
            2. Immutable value objects
            3. Domain events
            4. Intention-revealing interface
            5. Side-effect-free functions
            6. Assertions
            7. Conceptual contours
            8. Closure of operations
          4. Declarative design
      3. Protocol-oriented programming (POP)
        1. POP paradigms
          1. Protocol composition
          2. Protocol extensions
          3. Protocol inheritance
          4. Associated types
          5. Conforming to a protocol
      4. Functional Reactive Programming (FRP)
        1. Building blocks of FRP
          1. Signals
          2. Pipes
          3. Signal producers
          4. Buffers
          5. Observers
          6. Actions
          7. Properties
          8. Disposables
          9. Schedulers
        2. An example
      5. Mixing OOP and FP
        1. Problems
          1. Granularity mismatch
        2. FP paradigm availability
          1. First-class values
          2. Closures
          3. FP-OOP interrelation tools
        3. FP support
        4. Effects of having FP capabilities in OOP
          1. Idiomatic effects
          2. Architectural effects
        5. OOP design patterns - an FP perspective
          1. Strategy pattern
          2. Command pattern
          3. Observer pattern
          4. Virtual proxy pattern
          5. Visitor pattern
      6. Summary
    17. 11. Case Study – Developing an iOS Application with the FP and OOP Paradigms
      1. Requirements
      2. High-level design
        1. Frontend
          1. Models
          2. Views
          3. ViewController
          4. State
          5. Store
          6. Actions
          7. Manager
          8. Communication
          9. Communication between layers
          10. Third-party libraries
          11. Cross-cutting concerns
            1. Error management and exception handling
            2. Crash reporting
            3. Analytics
          12. Tools
        2. Backend
          1. Vapor
            1. Routing
            2. JSON
            3. Requesting data
          2. SPM
      3. Backend development
        1. Model
        2. Store
        3. Controller
          1. Posting a new Todo item
          2. Getting a list of Todo items
          3. Getting a specific Todo item
          4. Deleting an item and deleting all Todo items
          5. Updating a Todo item
      4. iOS application development
        1. Configuration
        2. Models
          1. Operators
            1. <^>
            2. <*>
            3. <|
            4. <|?
            5. <||
          2. Using Argo models
          3. ViewModel
        3. Communication
          1. Request protocol
          2. Conforming to a request protocol
          3. WebServiceManager
          4. Creating a Todo item
          5. Listing Todo items
        4. Lens
        5. State
        6. Store
        7. Action
        8. Views
        9. ViewController
          1. MasterViewController
            1. IBActions
            2. TableView Delegates and DataSource
          2. DetailsViewController
      5. Summary