Swift Functional Programming - Second Edition

By Dr. Fatih Nayebi

About This Book

• Written for the latest version of Swift, this is a comprehensive guide that introduces iOS, Web and macOS developers to the all-new world of functional programming that has so far been alien to them
• Get familiar with using functional programming alongside existing OOP techniques so you can get the best of both worlds and develop clean, robust, and scalable code
• Develop a case study on example backend API with Swift and Vapor Framework and an iOS application with Functional Programming, Protocol-Oriented Programming, Functional Reactive Programming, and Object-Oriented Programming techniques

Who This Book Is For

Meant for a reader who knows object-oriented programming, has some experience with Objective-C/Swift programming languages and wants to further enhance his skills with functional programming techniques with Swift 3.x.

• Language: English
• Publisher: Packt Publishing
• Release date: Apr 26, 2017
• ISBN: 9781787283459

Book preview

Title Page

Swift Functional Programming

Second Edition

Build clean, smart, and reliable applications with Swift Functional Programming

Dr. Fatih Nayebi

 BIRMINGHAM - MUMBAI

Copyright

Swift Functional Programming

Second Edition

Copyright © 2017 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: June 2016

Second edition: April 2017

Production reference: 1210417

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham 

B3 2PB, UK.

ISBN 978-1-78728-450-0

www.packtpub.com

Credits

About the Author

Dr. Fatih Nayebi has more than 15 years of industry experience in software engineering and architecture in various fields. He has developed numerous applications with Visual Basic, C++, C#, Java, MATLAB, Python, Objective-C, and Swift. He has been designing and developing enterprise and consumer iOS applications since the release of first iOS SDK. He is also an enthusiastic Node, Scala, and Haskell developer.

Aside from industry, Fatih earned his Ph.D. degree in software engineering from École de technologie supérieure, Université du Québec by researching on Mobile Human-Computer Interaction, Software Engineering, and Machine Learning.

His specialties include applied predictive and optimization models, human-computer interaction, functional programming, machine learning, and mobile application architecture and development.

Fatih currently works as a Director, Consulting at CGI Group Inc, Montreal, and continues to his academic research and publications as a postdoctoral researcher at École de technologie supérieure.

You can find him talking on Swift and Functional Programming at meetups such as http://www.meetup.com/swift-mtl/, on GitHub at https://github.com/conqueror, on Twitter as @thefatih, and on Instagram as @thefatih.

About the Reviewer

Giordano Scalzo is a developer with 20 years of programming experience, since the days of ZXSpectrum. He has worked in C++, Java, .NET, Ruby, Python and in a ton of other languages he has forgotten the names of.

After years of backend development, over the past five years, Giordano has developed extensively for iOS, releasing more than 20 apps, apps that he wrote for clients, enterprise application, or for his own company.

Currently, he is a contractor in London, where, through his company, Effective Code Ltd, http://effectivecode.co.uk, he delivers code for iOS aiming at quality and reliability.

In his spare time, when he is not crafting retro game clones for iOS, he writes his thoughts on http://giordanoscalzo.com.

I’d like to thank my better half, Valentina, who lovingly supports me in everything I do: without you, none of this would have been possible.

Thanks to my bright future, Mattia and Luca, for giving me lots of smiles and hugs when I needed them.

Finally, my gratitude goes to my mum and dad, who gave my curiosity and the support to follow my passions, begun one day when they bought me a ZXSpectrum.

www.PacktPub.com

For support files and downloads related to your book, please visit www.PacktPub.com.

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [e-mail] for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

https://www.packtpub.com/mapt

Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Customer Feedback

Thanks for purchasing this Packt book. At Packt, quality is at the heart of our editorial process. To help us improve, please leave us an honest review on this book's Amazon page at https://www.amazon.com/dp/1787284506.

If you'd like to join our team of regular reviewers, you can e-mail us at [e-mail]. We award our regular reviewers with free eBooks and videos in exchange for their valuable feedback. Help us be relentless in improving our products!

Dedication

For Grace,

being a father may make me a better person.

For Necmiye,

because of the love and support throughout the writing of this book.

For Fehiman,

I am grateful for everything you have done for us.

For Negar and Su Tamina,

love you all.

Table of Contents

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

Preface

Functional programming (FP) is getting a lot of attention as it eases many of the difficulties faced in object-oriented programming (OOP), such as testability, maintainability, scalability, and concurrency. Swift has a lot of functional programming features that can be easily used, but most Objective-C and Swift programmers are not very familiar with these tools.

This book aims to simplify the functional programming paradigms and make it easily usable for Swift programmers, showing you how to use popular functional programming techniques to solve many of your day-to-day development problems. Whether you are new to functional programming and Swift or experienced, this book will provide you with the skills you need to design and develop high quality, easily maintainable, scalable, and efficient applications for iOS Web, macOS, tvOS, and watchOS. Through this book, you'll learn to develop extendable, smart, and maintainable code using functional programming techniques.

What this book covers

Chapter  1, Getting Started with Functional Programming in Swift, introduces functional programming paradigms by attempting to answer the questions of Why functional programming matters? and What is functional programming? It covers topics such as immutability, stateless programming, pure, first-class, and higher-order functions. Also, this chapter will introduce the Swift programming language basics as they are essential for the rest of the book.

Chapter  2, Functions and Closures, begins with the definition of functions, continues with other related topics, such as function types, and finally concludes with more advanced topics such as first-class functions, higher-order functions, function composition, custom operator definition, closures, function currying, recursion, and memoization.

Chapter  3, Types and Type Casting, takes a look at types in general by introducing different kinds of types such as concrete, abstract, product, and sum. We will cover topics such as value and reference type constants, mixing value and reference types, and copying. Then, we will discuss the characteristics of value types. We will also cover the key differences between value and reference types, and how we should decide which one to use. Finally, we will explore equality, identity, type checking, and casting topics.

Chapter  4, Enumerations and Pattern Matching, explains the enumeration definition and usage. We will cover associated and raw values and being introduced to the concept of algebraic data types. We will explore some examples to cover the sum, product, and recursion types. Also, in this chapter, we will explore patterns such as wildcard, value-binding, identifier, tuple, enumeration case, optional, type casting, and expression, along with related pattern matching examples.

Chapter  5, Generics and Associated Type Protocols, teaches us how to define and use generics. We will also understand the type of problems generics solve. Moving forward, we will explore type constraints, generic data structures, and associated type protocols with examples. We will explore type erasure by an example and finally we will learn how to extend generic types and how to subclass generic classes.

Chapter  6, Map, Filter, and Reduce, introduces the concept of higher-kinded types, Functor, Applicative Functor, and Monad. This chapter covers higher-order functions/methods such as map, flatMap, filter, and reduce in the Swift programming language with examples. The chapter continues by providing implementation of map, filter, flatMap, and flatten in terms of reduce. Then it provides, apply, join, chaining higher-order functions, and zip. Finally, it provides practical examples of higher-order function usage.

Chapter  7, Dealing with Optionals, familiarizes us with different techniques to deal with optionals. We will talk about built-in techniques to deal with optionals, such as optional binding, guard, coalescing, and optional chaining. Then, we will explore functional programming techniques to deal with optionals. Finally, this chapter will cover the error handling with an example.

Chapter  8, Functional Data Structures, introduces the concept of functional data structures and explores examples of data structures implemented in a functional way, such as Semigroup, Monoid, BST, LinkedList, Stack, and LazyList.

Chapter  9, Importance of Immutability, explores the concept of immutability. We will look at its importance and benefits with the help of examples. Then we will consider cases for mutability and go through an example to compare mutability and immutability effects on our code. Finally, we will explore copy constructors and lenses.

Chapter  10, The Best of Both Worlds - Combining FP Paradigms with OOP, covers object- oriented programming principles and paradigms. Then, we will be introduced to protocol- oriented programming. Next, we will have an introduction of functional reactive programming and explore how to mix FP with OOP paradigms.

Chapter  11, Case Study - Developing an iOS Application with the FP and OOP Paradigms, teaches us to develop a Todo backend with Vapor framework and an iOS application, employing the concepts covered in previous chapters. We will use functional programming techniques to parse and map the data, we will use functional reactive programming to reactively manage events in applications. We will also employ protocol-oriented programming and object-oriented programming techniques as well.

What you need for this book

To follow along with the examples in this book, you'll need to have an Apple computer with macOS 10.10 or higher installed. You'll also need to install Xcode 8.3 or newer with Swift 3.1 or newer.

Who this book is for

This book is for iOS, Web, and macOS developers with basic knowledge of Swift programming who are interested in functional programming techniques. Prior knowledge of object-oriented programming and iOS app development familiarity is assumed.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: The VerboseClass.h file defines an interface as a subclass of the NSObject class.

A block of code is set as follows:

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "Next, we will create a Single View Application project in Xcode."

Warnings or important notes appear in a box like this.

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail [e-mail], and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book 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 files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Swift-Functional-Programming. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Downloading the color images of this book

We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from https://www.packtpub.com/sites/default/files/downloads/SwiftFunctionalProgramming_ColorImages.pdf.

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books-maybe a mistake in the text or the code-we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and