Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Swift Functional Programming
  • Toc
  • feedback
Swift Functional Programming

Swift Functional Programming

By : Nayebi
4.3 (3)
close
Swift Functional Programming

Swift Functional Programming

4.3 (3)
By: Nayebi

Overview of this book

Swift is a multi-paradigm programming language enabling you to tackle different problems in various ways. Understanding each paradigm and knowing when and how to utilize and combine them can lead to a better code base. Functional programming (FP) is an important paradigm that empowers us with declarative development and makes applications more suitable for testing, as well as performant and elegant. This book aims to simplify the FP paradigms, making them easily understandable and usable, by showing you how to solve many of your day-to-day development problems using Swift FP. It starts with the basics of FP, and you will go through all the core concepts of Swift and the building blocks of FP. You will also go through important aspects, such as function composition and currying, custom operator definition, monads, functors, applicative functors,memoization, lenses, algebraic data types, type erasure, functional data structures, functional reactive programming (FRP), and protocol-oriented programming(POP). You will then learn to combine those techniques to develop a fully functional iOS application from scratch
Table of Contents (12 chapters)
close
close
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Free Chapter
1
Getting Started with Functional Programming in Swift
Getting Started with Functional Programming in Swift
Why functional programming matters
What is FP?
The Swift programming language
Summary
2
Functions and Closures
Functions and Closures
What is a function?
Syntax
Pure functions
Function types
First-class functions
Higher-order functions
Function composition
Closures
Function currying
Recursion
Memoization
Summary
3
Types and Type Casting
Types and Type Casting
Kinds of types
Value versus reference types
Equality versus identity
Equatable and Comparable
Type checking and casting
Summary
4
Enumerations and Pattern Matching
Enumerations and Pattern Matching
Defining enumerations
Algebraic data types
Pattern matching
Summary
5
Generics and Associated Type Protocols
chevron up
Generics and Associated Type Protocols
What are Generics and what kind of problems do they solve?
Type constraints
Generic data structures
Associated type protocols
Type erasure
Extending Generic types
Subclassing Generic classes
Generics manifesto
Summary
6
Map, Filter, and Reduce
Map, Filter, and Reduce
Higher-kinded types
The map function
The flatMap method
The filter function
The reduce function
The apply function
The join function
Chaining higher-order functions
The zip function
Practical examples
Summary
7
Dealing with Optionals
Dealing with Optionals
Optional types
Unwrapping optionals
Guard
Implicitly-unwrapped optionals
Nil-coalescing
Optional chaining
Dealing with Optionals' functionally
Error handling
Summary
8
Functional Data Structures
Functional Data Structures
Semigroups
Monoids
Trees
Lists
Stacks
Lazy lists
Summary
9
Importance of Immutability
Importance of Immutability
Immutability
Immutable variables
Reference types versus value types
Benefits of immutability
Cases for mutability
An example
Copy constructors and lenses
Summary
10
Best of Both Worlds and Combining FP Paradigms with OOP
Best of Both Worlds and Combining FP Paradigms with OOP
OOP paradigms
OOP design principles
POP
Functional reactive programming
Mixing OOP and FP
Summary
11
Case Study - Developing an iOS Application with FP and OOP Paradigms
Case Study - Developing an iOS Application with FP and OOP Paradigms
Requirements
High-level design
Backend development
iOS application development
Summary

Type erasure

In Chapter 3, Types and Type Casting we talked about Abstract versus Concrete types. Type erasure is a process to make abstract types such as Generics concrete.

Why we would want to do it? The answer is because we want to write code against contracts; in other words, we want to prefer composition over inheritance. Also, sometimes we would want to be more flexible with the types. This concept may sound complicated, so let's continue our example from the previous section to understand why and how we would create type-erased structures.

First, we want to examine if we can use CustomView type and create an array with CustomView elements. We will create a CustomView:

struct CustomDisabledButton: CustomView { 
    typealias ViewType = Button 
    func configure(view with: ViewType) { 
        // configure the view 
        print("Disabled button") 
    } 
}

So far, we've created two CustomViews; the first one represents a custom enabled button and the second one represents a disabled...

End of Section 7
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete