Swift Functional Programming - Second Edition电子书

Title Page

Copyright

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Getting Started with Functional Programming in Swift

Why functional programming matters

What is FP?

The Swift programming language

Swift features

Modern syntax

Type safety and type inference

Immutability

Stateless programming

First-class functions

Higher-order functions

Closures

Subscripts

Pattern matching

Generics

Optional chaining

Extensions

Objective-C and Swift bridging headers

Automatic Reference Counting

REPL and Playground

Language basics

Types

Type inference

Type annotation

Type aliases

Type casting

Immutability

Tuples

Optionals

Basic operators

Strings and characters

Immutability

String literals

Empty Strings

Concatenating strings and characters

String interpolation

String comparison

Collections

Control flows

for loops

while loops

The stride functions

if

Switch

Guard

Functions

Closures

The map, filter, and reduce functions

The map function

The filter function

The reduce function

Enumerations

Generics

Classes and structures

Classes versus structures

Choosing between classes and structures

Identity operators

Properties

Property observers

Methods

Subscripts

Inheritance

Initialization

De-initialization

Automatic Reference Counting

Any and AnyObject

Nested types

Protocols

Protocols as types

Extensions

Protocol extensions

Access control

Error handling

Summary

Functions and Closures

What is a function?

Syntax

Best practices in function definition

Calling functions

Defining and using function parameters

Defining and using variadic functions

Returning values from functions

Defining and using nested functions

Pure functions

Function types

First-class functions

Higher-order functions

Function composition

Custom operators

Allowed operators

Custom operator definition

A composed function with custom operator

Closures

Closure syntax

Capturing values

Function currying

Recursion

Tail recursion

Memoization

Summary

Types and Type Casting

Kinds of types

Value versus reference types

Value and reference type constants

Mixing value and reference types

Copying

Copying reference types

Value type characteristics

Behaviour

Isolation

Interchangeability

Testability

Threats

Using value and reference types

Equality versus identity

Equatable and Comparable

Type checking and casting

Summary

Enumerations and Pattern Matching

Defining enumerations

Associated values

Raw values

Nesting and containing enumerations

Algebraic data types

Simple types

Composite types

Composite types with variants

The algebra of data types

Pattern matching

Patterns and pattern matching

The wildcard pattern

The value-binding pattern

The identifier pattern

The tuple pattern

The enumeration case pattern

The optional pattern

Type casting patterns

The expression pattern

Summary

Generics and Associated Type Protocols

What are Generics and what kind of problems do they solve?

Type constraints

The where clauses

Generic data structures

Associated type protocols

Type erasure

Extending Generic types

Subclassing Generic classes

Generics manifesto

Summary

Map, Filter, and Reduce

Higher-kinded types

Functors

Applicative Functors

Monads

The map function

The flatMap method

The filter function

The reduce function

The map function in terms of reduce

The filter function in terms of reduce

The flatMap function in terms of reduce

The flatten function in terms of reduce

The apply function

The join function

Chaining higher-order functions

The zip function

Practical examples

Sum and product of an array

Removing nil values from an array

Removing duplicates in an array

Partitioning an array

Summary

Dealing with Optionals

Optional types

Unwrapping optionals

Force unwrapping

nil checking

Optional binding

Guard

Implicitly-unwrapped optionals

Nil-coalescing

Optional chaining

Dealing with Optionals' functionally

Optional mapping

Multiple optional value mapping

Error handling

try!

try?

Summary

Functional Data Structures

Semigroups

Monoids

Trees

The contains method

Binary Search Trees

The contains method

Size

Elements

Empty

Lists

Empty LinkedList

Cons

Contains

Size

Elements

isEmpty

map, filter, and reduce

Stacks

Lazy lists

Summary

Importance of Immutability

Immutability

Immutable variables

Weak versus strong immutability

Reference types versus value types

Benefits of immutability

Thread safety

Referential transparency

Low coupling

Avoiding temporal coupling

Avoiding identity mutability

Failure atomicity

Parallelization

Exception handling and error management

Caching

State comparison

Compiler optimization

Cases for mutability

An example

Side-effects and unintended consequences

Testability

Copy constructors and lenses

Copy constructors

Lenses

Lens composition

Summary

Best of Both Worlds and Combining FP Paradigms with OOP

OOP paradigms

Objects

Classes

Inheritance

Overriding

Design constraints

Singleness

Static

Visibility

Composite reuse

Issues and alternatives

When to inherit

Polymorphism

Dynamic binding

OOP design principles

SRP

The FP counterpart

OCP

The FP counterpart

LSP

The FP counterpart

ISP

The FP counterpart

DIP

The FP counterpart

DDD

Concepts

Premise

Building blocks

Aggregate

Immutable value objects

Domain events

Intention-revealing interface

Side-effect-free functions

Assertions

Conceptual contours

Closure of operations

Declarative design

POP

POP paradigms

Protocol composition

Protocol extensions

Protocol inheritance

Associated types

Conforming to a protocol

Functional reactive programming

Building blocks of FRP

Events

Signals

Pipes

Signal producers

Observers

Lifetimes

Actions

Properties

Disposables

Schedulers

An example

Mixing OOP and FP

Problems

Granularity mismatch

FP paradigm availability

First-class values

Closures

FP-OOP interrelation tools

FP support

Effects of having FP capabilities in OOP

Idiomatic effects

Code abstraction at a function/method level

Generic iterator operations

Operation compositions and sequence comprehensions

Function partial applications and currying

Architectural effects

Reduction of the number of object/class definitions

Name abstraction at a function/method level

OOP design patterns - a FP perspective

Strategy pattern

Command pattern

Observer pattern

Virtual proxy pattern

Visitor pattern

Summary

Case Study - Developing an iOS Application with FP and OOP Paradigms

Requirements

High-level design

Frontend

Models

Views

ViewController

State

Store

Actions

Manager

Communication

Communication between layers

Third-party libraries/frameworks

Cross-cutting concerns

Error management and exception handling

Tools

Backend

Vapor

Routing

JSON

Request data

SPM

Backend development

Model

Store

Controller

Posting a new Todo item

Getting a list of Todo items

Getting a specific Todo item

Deleting an item and deleting all Todo items

Updating a Todo item

iOS application development

Configuration

Models

Operators

<^> operator

<*> operator

<| operator

<|? operator

<|| operator

Using Argo models

viewModel

Communication

The request protocol

Conforming to the request protocol

WebServiceManager

Creating a Todo item

Listing Todo items

Lenses

States

Store

Actions

Views

ViewControllers

MasterViewController

IBActions

TableView delegates and DataSource

DetailsViewController

Summary