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
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
chevron up
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

Dealing with Optionals' functionally

We have covered different approaches and tools to deal with Optionals so far. Let's examine if we can use functional programming paradigms to simplify the process.

Optional mapping

Mapping over an array would generate one element for each element in the array. Can we map over an optional to generate non-optional values? If we have some, map it; otherwise, return none. Let's examine the following code:

func mapOptionals<T, V>(transform: (T) -> V, input: T?) -> V? { 
    switch input { 
    case .some(let value): return transform(value) 
    case .none: return .none 
    } 
}

Our input variable is a generic optional and we have a transform function that takes input and transforms it into a generic type. The result will be a generic optional type. In the function body, we use pattern matching to return the respective values. Let's test this function:

class User { 
    var name: String? 
}

We create a class named User with an optional variable. We...

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