Swift Functional Programming

By : Nayebi

4.3 (3)

Buy this Book

Swift Functional Programming

4.3 (3)

By: Nayebi

Buy this Book

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

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

Getting Started with Functional Programming in Swift

Why functional programming matters

What is FP?

The Swift programming language

Summary

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

Types and Type Casting

Kinds of types

Value versus reference types

Equality versus identity

Equatable and Comparable

Type checking and casting

Summary

Enumerations and Pattern Matching

Defining enumerations

Algebraic data types

Pattern matching

Summary

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

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

Dealing with Optionals

Optional types

Unwrapping optionals

Guard

Implicitly-unwrapped optionals

Nil-coalescing

Optional chaining

Dealing with Optionals' functionally

Error handling

Summary

Functional Data Structures

Semigroups

Monoids

Trees

Lists

Stacks

Lazy lists

Summary

Importance of Immutability

Immutability

Immutable variables

Reference types versus value types

Benefits of immutability

Cases for mutability

An example

Copy constructors and lenses

Summary

Best of Both Worlds and Combining FP Paradigms with OOP

OOP paradigms

OOP design principles

POP

Functional reactive programming

Mixing OOP and FP

Summary

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

Requirements

High-level design

Backend development

iOS application development

Summary

Customer Reviews

4.3 (3)

5 star

66.7%

4 star

3 star

33.3%

2 star

1 star

Backend development

We want to develop a very simple backend for a Todo application. Please note that Vapor is in active development and our backend application will need regular updates to keep up. Therefore, our GitHub (https://github.com/PacktPublishing/Swift-Functional-Programming) repository will be updated frequently.

Model

We will start by creating our model. The code is as follows:

import Vapor 
import Fluent 

final class Todo: Model { 
    var id: Node? 
    var todoId: Int 
    var name: String 
    var description: String 
    var notes: String 
    var completed: Bool 
    var synced: Bool 

    var exists: Bool = false 

    init(node: Node, in context: Context) throws { 
        id = try node.extract("id") 
        todoId = try node.extract("todoId...

Your notes and bookmarks

Swift Functional Programming

By : Nayebi

Swift Functional Programming

By: Nayebi

Overview of this book

Delete Bookmark