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

Lazy lists

So far, we have implemented a linked list and a stack as a list. One of the key concepts in FP is the concept of lazy evaluation. We can make our list lazy so that the elements will be evaluated once we access them. We need to change node in such a way that it will return a function containing list as next, instead of the list itself. The function will be evaluated when it is called; therefore, our list will be lazy.

We start with modifying our node case. In our LinkedList example, next was of the LinkedList<Element> type. To make our list lazy, we will modify next to be a function that returns our list:

enum LazyList<Element: Equatable> { 
    case end 
    case node(data: Element, next: () -> LazyList<Element>) 
}

As we can see in the preceding code, our node case is not defined as indirect because next is not of the LazyList type and is a reference to a function that returns LazyList.

We need to accommodate this change into our properties and methods. It is...

End of Section 5
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