book

Functional Programming with C#

Name: Functional Programming with C#
Author: Alex Yagur
ISBN: 9781805122685

by Alex Yagur

July 2024

Beginner to intermediate

258 pages

5h 11m

English

Packt Publishing

Read now

Unlock full access

Functional Programming with C#
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1:Foundations of Functional Programming in C#
Chapter 1: Getting Started with Functional Programming
Functional versus imperative versus object-oriented programmingImperative programmingObject-oriented programmingFunctional programmingBlending paradigmsHow functional programming is supported in C#How to write functional code in C#A practical example – a book publishing systemHow to combine functional and object-oriented paradigmsMeet Steve and JuliaSummary
Chapter 2: Expressions and Statements
Task 1 – Name and count all expressions and all statementsTask 2 – Use expressions instead of statementsTask 3 – Create an expression treeUnderstanding the difference between expressions and statementsExample of expressionsExample of statementsKey differences between expressions and statementsGuided exercise – finding expressions and statements in sample codeHow to use expressions for clear and simple codeThe power of expressions – improving readability and maintainabilityTechniques to convert statements to expressionsGuided exercise – refactoring code using expressionsLambda expressions, expression-bodied members, and anonymous methodsWhat are lambda expressions?Multiple parameters in lambda expressionsLambda expressions evolutionUnderstanding anonymous methodsHow do anonymous methods work?When to use anonymous methodsPractical examples – applying these features in real codeExpression-bodied membersExercise – implementing lambda expressions and anonymous methodsExpression trees and how to use them to manipulate expressions at runtimeBuilding and manipulating expression treesCreating and manipulating complex expression treesQuerying data with expression trees – LINQ and beyondGuided exercise – constructing and manipulating expression treesProblem sets and exercisesExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 3: Pure Functions and Side Effects
Task 1 – Refactoring to a pure functionTask 2 – Isolating side effectsTask 3 – Using a Pure attributeUnderstanding pure functionsExamples of pure functionsThe benefits of pure functionsComparisons of pure functions and non-pure functionsSide effectsCommon sources of side effectsConsequences of side effectsStrategies to minimize side effectsFavor immutabilityUse readonly and constUse functional programming principlesEncapsulate side effectsMarking pure functions with the Pure attributeUnderstanding the Pure attribute in C#The benefits of marking functions as pureCaveats and considerations when using the Pure attributeExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 4: Honest Functions, Null, and Option
Task 1 – Refactor for honest return typesTask 2 – Guard against null inputsTask 3 – Pattern matching with nullable typesHonest functions – definition and understandingThe problems with hidden nullsA quick look back – C# and nullCommon mistakes and the troubling NullReferenceExceptionNot all bad – the value of nullEmbracing honesty with nullable reference typesWhat are nullable reference types?Transitioning to NRTsEnabling nullable reference typesDisabling nullable reference typesWarnings and annotations optionsThe bigger picture – project-wide settingsReturning with intentionThe distinction between UserProfile and UserProfile?Honoring a function’s contractDemanding honesty from function inputsNullable reference types to the rescueUsing preconditions and contractsUsing built-in checksThe power of explicit non-null inputsPattern matching and nullable typesPattern matching with nullable typesSwitch expressions with property patternsEnsuring clarity with nullable typesThe null object patternThe problem with null checksThe null object solutionAdvantagesLimitations and considerationsBeyond null – using OptionA brief introduction to OptionAdvantages of the Option type over nullable typesThe interplay of Option and nullable typesPractical scenarios – handling nulls effectivelyCase study – managing YouTube videosCase study – managing different video typesCase study – working with non-existing objectsThe impact of handling nulls in real-world scenariosThe reality of honesty in C# – why there will never be truly honest functionsThe compromises of the C# language designPractical tips and best practicesStrategies for migrating existing code bases to adopt nullable reference types and OptionCommon pitfalls and how to navigate themTesting strategies for null and Option handlingExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Part 2:Advanced Functional Techniques
Chapter 5: Error Handling
Task 1 – Custom error types and result usageTask 2 – Utilizing ROP for validation and processingTask 3 – Implementing a Retry mechanism using functional techniquesTraditional error handling in C#try-catch blocksExceptionsThe Result typeImplementing the Result typeUsing the Result typeRailway-Oriented Programming (ROP)The essence of BindChaining operations with BindComposable error handling with ROPHandling diverse error typesBenefits of isolationExtending ROP for asynchronous operationsDesigning your own error-handling mechanismsUse factory methods for creationExtend with BindCustomize error typesLeverage extension methodsIntegration with existing codeAlways iterate and refinePractical tips for functional error handlingAvoid null with optionsLogging errorsTwo strategies To replace exceptionsAnticipate errors – make it predictableEmbrace compositionEducate your teamTraditional versus functional error handling comparisonThe traditional wayThe functional wayComparative analysisMaking the shiftPatterns and anti-patterns in functional error handlingExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 6: Higher-Order Functions and Delegates
Task 1 – Sorting functionTask 2 – Customized calculationsTask 3 – ComparisonUnderstanding higher-order functionsThe power of higher-order functions in functional programmingCreating versatile code with fewer errorsSupporting a more declarative coding styleDelegates, actions, funcs, and predicatesDelegatesActionsFuncsPredicatesCallbacks, events, and anonymous methodsThe role of delegates in eventsDelegates and anonymous methodsHarnessing LINQ methods as higher-order functionsFilteringData transformationData aggregationCase study – putting it all togetherStep-by-step walk-through and analysis of the codeBest practices and common pitfallsExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary

Chapter 7: Functors and Monads
Task 1 – Functor usageTask 2 – Applicative functorTask 3 – Monad usageWhat’s a functor?Identity lawComposition lawCreating our own functorFunctor benefitsApplicative functorsThe Apply method implementationApplicative functor lawsMonadsThe Bind methodMonad lawsUtilizing monadsKey takeawaysExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Part 3:Practical Functional Programming
Chapter 8: Recursion and Tail Calls
Task 1 – Recursive enemy countTask 2 – Wave generationTask 3 – Asynchronously updating enemy statsIntroducing recursionRecursive thinkingTypes of recursionSimple recursionTail recursionChallenges of recursionStack overflow riskDefault stack size and limitationsPerformance considerationsLeveraging C# features for recursionLocal functionsPattern matchingAdvanced recursive patternsMutual recursionMemoizationComparison with iterative solutionsReadabilityPerformanceRecursion in asynchronous programmingExplaining asynchronous recursion under the hoodSynchronous versus asynchronous recursionScenarios for asynchronous recursionExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 9: Currying and Partial Application
Task 1 – Currying tower attack functionsTask 2 – Partial application for game settingsTask 3 – Currying permission checks for game featuresUnderstanding curryingStandard approachCurried approachStep-by-step implementation of curryingUse casesConfiguration settingsEvent handlingPartial applicationAsynchronous programmingPartial applicationAreas for partial applicationExample of partially applying a function for configuration settingsStandard rendering functionPartially applied functionChallenges and limitationsExercisesExercise 1Exercise 2Exercise 3SolutionsSolution 1Solution 2Solution 3Summary
Chapter 10: Pipelines and Composition
Task 1 – Enemy wave processing pipelineTask 2 – Game data file processingTask 3 – Dynamic SQL query generation using currying and partial applicationFunction compositionBuilding pipelinesPerformance considerationsThe fluent interfaceAdvanced composition with monadsExercisesExercise 1Exercise 2Exercise 3SolutionsSolution 1Solution 2Solution 3Summary
Part 4:Conclusion and Future Directions
Chapter 11: Reflecting and Looking Ahead
A summary of the main concepts and techniquesComparison with other languagesResources for further learningClosing thoughts
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Functional Programming with C#

Part 2:Advanced Functional Techniques

Building on the foundations established in Part I, we now delve into more advanced functional programming techniques. We’ll start by exploring functional approaches to error handling, moving beyond traditional try-catch blocks to more elegant solutions. Next, we’ll cover higher-order functions and delegates, unlocking the power of functions as first-class citizens. The section concludes with an in-depth look at functors and monads, advanced concepts that provide powerful tools for managing complexity in your code.

This part has the following chapters:

Chapter 5, Error Handling
Chapter 6, Higher-Order Functions and Delegates
Chapter 7, Functors and Monads

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781805122685

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Functional Programming with C#

by Alex Yagur

Part 2:Advanced Functional Techniques

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.