Index
A
- Abraham, Isaac, Active Patterns, Learn F#
- Action delegates
- Advent of Code code challenge site, Taking It Further: Develop Your Functional Skills, Functional C# and Performance
- adventure game, text-based, Pattern Matching in C# 11
- (see also Martian Trail game)
- Aggregate() (LINQ), Many to One: The Subtle Art of Aggregation
- aggregation
- Albahari, Joseph, Read-Only Structs
- All() (LINQ), A Super-Simple Validator
- alt combinator, Alt Combinator
- Any() (LINQ), Funcs in Enumerables
- “Applying Functional Principles in C# 6” (Khorikov), CSharpFunctionalExtensions
- arrays
- associativity law for monads, Associativity Law
- async functions and Maybe DU, Maybe and Async
- author website, What About You?
- AutoMapper library (Bogard), Map() Versus Bind(), Option
- average calculated via Fork(), Fork Combinator
- Average() (LINQ), Many to One: The Subtle Art of Aggregation
- await statement for value to pass to Bind(), Maybe and Async
B
- Bachchan, Amitabh, Bacon Numbers
- Bacon numbers, Bacon Numbers-Bacon Numbers
- Bacon, Kevin, Bacon Numbers
- bank account pattern matching example
- BASIC language, The Martian Trail
- behavior-driven development (BDD), Testable
- benefits of functional programming, The Benefits of Functional Programming-Reduced Code Noise, How Do I Convince My Teammates to Do This Too?
- Bernhardt, Gary, Referential transparency
- Bind()
- debug tools in Visual Studio and, Maybe and Debugging
- as functor, Right Identity Law
- Map() versus, Map() Versus Bind(), Option
- Maybe DU with, Maybe, Revisited-Maybe, Revisited
- Reader monad for database connection, Reader-Reader
- mock IDbConnection unit tests, Reader
- State monads, State-State
- Bogard, Jimmy, Map() Versus Bind(), Option
- book web page, How to Contact Us
- British and Chinese names via discriminated unions, Naming Conventions-Naming Conventions
- bugs from null values, Nullable Reference Types
- (see also debugging; error handling)
- Build section of project properties, Nullable Reference Types-Nullable Reference Types
- Buonanno, Enrico, Acknowledgments, More Functional C#
C
- C#
- about functional programming, Preface
- C# 7 and beyond
- F# code referenced in C#, Interop with F# performance-Interop with F# performance
- FAQ about functional C#
- getting started, What Can We Do Already?
- (see also getting started)
- hybrid object-oriented/functional language, Where Does Functional Programming Come From?, Is It Worth Learning a Pure Functional Language First?, Functional Coding in C# 7 and Beyond, What Kind of Day Has It Been?
- immutability not enforced by, Making Your Code Immutable
- increasing support for FP, Multiparadigm Languages
- LINQ, Multiparadigm Languages
- multiparadigm language, Multiparadigm Languages
- objects passed by reference, Stateless
- pattern matching in old versions of C#, Pattern Matching for Old Versions of C#-Pattern Matching for Old Versions of C#
- pattern matching with switch, Pattern matching
- performance (see performance of functional C#)
- primitive types, Maybe and the Primitives
- C# 10 in a Nutshell (Albahari), Read-Only Structs
- caching (see memoization)
- calculations stored in bundle of code to be executed on request as thunks, Thunks-Thunks
- Casarin, William, Functional.Maybe
- Celsius-Fahrenheit conversions
- chaining functions (chain and pipe), Chaining Functions-Chaining Functions
- Tap() to inspect at any point, Tap
- Chinese and British names via discriminated unions, Naming Conventions-Naming Conventions
- Church, Alonzo, Where Does Functional Programming Come From?
- Chutes and Ladders game (see Snakes and Ladders game)
- classes and functional C#, How Should I Structure a Functional C# Solution?
- code challenge sites, Taking It Further: Develop Your Functional Skills, Functional C# and Performance
- combinators, Higher-Order Functions
- combinatory logic of Curry, Where Does Functional Programming Come From?, Currying and Partial Application
- Common project for sharing functional code among apps, How Do I Share My Functional Methods Among Applications?
- compiler option for nullable reference types, Nullable Reference Types-Nullable Reference Types
- composing complex functions from simpler, Compose-Compose
- concise code in functional programming, Concise
- concurrency support in FP, Better Support for Concurrency
- console input for Oregon Trail via discriminated unions, Console Input-Console Input
- contact information for author, What About You?
- containerization, Better Support for Concurrency
- copy-paste and unit-test coverage, A Problem Report-A Problem Report
- Crockford, Douglas, Multiparadigm Languages,
Monads Actually, Don’t Worry About This Yet
- CSharpFunctionalExtensions (Khorikov maintaining), CSharpFunctionalExtensions-Result
- CSPROJ file, Nullable Reference Types-Nullable Reference Types
- CSV parser code, Putting It All Together: A Complete Functional Flow-Putting It All Together: A Complete Functional Flow
- Curry, Haskell Brooks, Where Does Functional Programming Come From?, Currying and Partial Application
- currying
- custom iterator, Customized Iteration Behavior-Customized Iteration Behavior
D
- Data.Maybe abandoned project (Casarin), Functional.Maybe
- database connection in Reader monad, Reader-Reader
- LanguageExt implementation, Reader
- mock IDbConnection unit tests, Reader
- database lookup via discriminated unions, Database Lookup-Database Lookup
- debugging
- declarative programming paradigm, Is It a Language, an API, or What?
- deferred execution, Understanding Enumerables
- delegate types, Higher-order functions
- dependency injection
- dictionaries
- Dillenberger, Paul, The Martian Trail
- discriminated unions (DUs)
- about, Discriminated Unions, Discriminated Unions
- console input for Oregon Trail via, Console Input-Console Input
- database lookup via, Database Lookup-Database Lookup
- error handling return values via, Database Lookup-Database Lookup
- generic unions
- about, Generic Unions
- Either for different return types, Either
- Either monad in Functional.Maybe library, Functional.Maybe-Functional.Maybe
- IEnumerable return type, Maybe Versus Result, Map() Versus Bind()
- Maybe, Maybe, Functional Flow
- Maybe and async, Maybe and Async
- Maybe and async with nested Maybes, Nested Maybes
- Maybe and logging, Maybe and Logging-Maybe and Logging
- Maybe and the primitives, Maybe and the Primitives-Maybe and the Primitives
- Maybe as monad, Other Structures
- Maybe versus Result, Maybe Versus Result-Maybe Versus Result
- Maybe with Bind(), Maybe, Revisited-Maybe, Revisited
- Maybe with Bind() and debugging, Maybe and Debugging
- Maybe with Bind() versus Map(), Map() Versus Bind(), Option
- Maybe with State monad, Maybe a State?
- Maybes nested, Nested Maybes-Nested Maybes
- Option in LanguageExt for Maybe, Option-Option
- Result, Result
- international name handling via, Naming Conventions-Naming Conventions
- OneOf NuGet package, OneOf-OneOf
- Schrödinger’s cat analogy, Schrödinger’s Union
- sending email via, Sending Email
- travel agency system for package holidays
- Doctor Who
- Dollard, Kathleen, Acknowledgments
- doughnut functions, Thunks
- driverless car monad worked example, A Worked Example-A Worked Example
- DUs (see discriminated unions)
E
- Egremont, Carlton, III, What Kind of Day Has It Been?
- Either DU for different return types, Either
- Either monad in Functional.Maybe library, Functional.Maybe-Functional.Maybe
- Elixir as pure functional language, Pure Functional Languages
- Elm as pure functional language, Pure Functional Languages
- email sent via discriminated unions, Sending Email
- Enumerable.Range, No starting array-No starting array
- Enumerable.Repeat, No starting array-No starting array
- enumerables
- Any() (LINQ), Funcs in Enumerables
- custom enumerations
- DU IEnumerable return type, Maybe Versus Result, Map() Versus Bind()
- Enumerable.Range and Enumerable.Repeat, No starting array-No starting array
- explanation of, Understanding Enumerables-Understanding Enumerables
- fork combinator converting single item into array, Fork Combinator
- Funcs in enumerables, Funcs in Enumerables
- as monads, Enumerable
- pattern matching on contents, Pattern Matching in C# 11
- Select() when iterator value required, Iterator value is required
- SelectMany() (LINQ), Nested Maybes
- transducers, Transduce
- updating, Update an Enumerable-Update an Enumerable
- enumerator
- Environment monads, Other Structures
- error handling
- error logging in try/catch blocks, Try/Catch-Try/Catch
- Essential F# (Russell), Active Patterns, Learn F#
- exceptions
- expressions rather than statements
- extension methods
F
- F#
- active patterns, Active Patterns
- common runtime with C#, Preface, Active Patterns
- discriminated unions available, Discriminated Unions, Discriminated Unions
- F# code referenced in C#, Interop with F# performance-Interop with F# performance
- learning, Learn F#
- multiparadigm language, Multiparadigm Languages
- pattern matching with switch, Pattern matching
- risk of coding in, What About F#? Should I Be Learning F#?
- tail call optimized recursion, Customized Iteration Behavior, Recursion
- F# for Fun and Profit (Wlaschin), Active Patterns, Learn F#
- F# in Action (Abraham), Active Patterns
- Fahrenheit-Celsius conversions
- FAQ about functional C#
- FirstOrDefault() (LINQ), Pattern Matching for Old Versions of C#
- Fluent Assertions in CSharpFunctionalExtensions, Fluent Assertions
- fork combinator, Fork Combinator-Fork Combinator
- Fork(), Fork Combinator
- FP (see functional programming)
- Frege, Friedrich, Where Does Functional Programming Come From?
- Func delegates
- about, Higher-order functions, It’s Time to Get Func-y
- alt combinator, Alt Combinator
- chaining functions, Chaining Functions-Chaining Functions
- Tap() to inspect at any point, Tap
- composing complex functions, Compose-Compose
- Fahrenheit-Celsius conversions, Compose
- fork combinator, Fork Combinator-Fork Combinator
- Funcs in enumerables, Funcs in Enumerables
- pattern matching in old versions of C#, Pattern Matching for Old Versions of C#-Pattern Matching for Old Versions of C#
- State monad CurrentValue, Maybe a State?
- thunks, Thunks-Thunks
- transducers, Transduce
- try/catch returned via, Try/Catch
- Functional Core, Imperative Shell (Bernhardt), Referential transparency
- functional programming (FP)
- about, Preface, Why I Wrote This Book
- benefits of, The Benefits of Functional Programming-Reduced Code Noise, How Do I Convince My Teammates to Do This Too?
- best places to use, The Best Places to Use Functional Programming
- FAQ about functional C#
- getting started, What Can We Do Already?
- (see also getting started)
- history of, Introduction, Where Does Functional Programming Come From?, Currying and Partial Application
- object-oriented programming complementing, Thunks
- objects changed via deliberate assignment, Stateless
- performance (see performance of functional C#)
- programming paradigm, Is It a Language, an API, or What?
- properties of
- expressions rather than statements, Expressions rather than statements
- functions of functional programming, Higher-order functions
- higher-order functions, Higher-order functions
- immutability, Immutability, Seriously, recursion, Making Your Code Immutable
- pattern matching, Pattern matching
- recursion, Recursion, Seriously, recursion
- referential transparency, Referential transparency-Referential transparency
- stateless, Stateless-Stateless
- pure functional languages, Who Else Does Functional Programming?-What About F#? Should I Be Learning F#?
- when other paradigms should be used, Where You Should Consider Using Other Paradigms
- Functional Programming in C# (Buonanno), Acknowledgments, More Functional C#
- “Functional Techniques for C#” (Dollard), Acknowledgments
- Functional.Maybe NuGet package (Tsvetkov), Functional.Maybe-Functional.Maybe
- functions
- break-out functions containing complex logic, Focusing on Results-Oriented Programming
- chaining functions, Chaining Functions-Chaining Functions
- Tap() to inspect at any point, Tap
- currying, Currying and Partial Application
- doughnut functions, Thunks
- extension methods
- filtering via, Make Dictionaries More Useful
- first functional code, A Functional Film Query
- functions of functional programming, Higher-order functions
- functors, Right Identity Law
- higher-order functions, Higher-Order Functions-Higher-Order Functions
- (see also higher-order functions)
- methods versus, Higher-order functions
- monads (see monads)
- pure functions, Referential transparency
- referential transparency, Referential transparency-Referential transparency
- trying a series until success or end, Alt Combinator
- unary functions, Partial Application
- functors, Right Identity Law
H
- Hanks, Tom, Bacon Numbers
- Haskell
- Heinemann, Bill, The Martian Trail
- higher-order functions
- about, Higher-order functions, Higher-Order Functions-Higher-Order Functions
- alt combinator, Alt Combinator
- chaining functions, Chaining Functions-Chaining Functions
- Tap() to inspect at any point, Tap
- composing complex functions, Compose-Compose
- currying and, Currying and Higher-Order Functions
- delegate types, Higher-order functions
- enumerables updated, Update an Enumerable-Update an Enumerable
- fork combinator, Fork Combinator-Fork Combinator
- functional programming property, Higher-order functions
- null handling, Handling Nulls-Handling Nulls
- problem report showing need for, A Problem Report-A Problem Report
- thunks, Thunks-Thunks
- transducers, Transduce
- try/catch blocks, Try/Catch-Try/Catch
- history of functional programming, Introduction, Where Does Functional Programming Come From?, Currying and Partial Application
- Hoare, Tony, Nullable Reference Types, Handling Nulls
- holiday package travel agency system
- Hugener-Olsen, Kim, Discriminated Unions
- hypotenuse of triangle via Fork(), Fork Combinator
I
- IDbConnection via Reader monad, Reader-Reader
- mock IDbConnection unit tests, Reader
- IDE and compiler option for nullable reference types, Nullable Reference Types-Nullable Reference Types
- Identity functor, Right Identity Law
- Identity monads, Other Structures
- IEnumerable
- IEnumerator, Custom Iterator
- IL (see Intermediate Language)
- immutability
- imperative programming paradigm, Is It a Language, an API, or What?
- indefinite iterators, Using Indefinite Iterators-Using Indefinite Iterators
- indefinite loops
- Information Processing Language (IPL), Where Does Functional Programming Come From?
- Init, Init-Only Setters
- init-only setters, Init-Only Setters
- Intermediate Language (IL)
- international names via discriminated unions, Naming Conventions-Naming Conventions
- interop F# code into C#, Interop with F# performance-Interop with F# performance
- inversion-of-control (IoC) container, Other Structures, How Should I Structure a Functional C# Solution?
- IO monads, Other Structures
- is operator, Pattern Matching in C# 7-Pattern Matching in C# 7
- IterateUntil() extension method
- iteration
L
- lambda expressions, Where Does Functional Programming Come From?
- LanguageExt NuGet package (Louth), LanguageExt-LanguageExt Wrap-up
- about, LanguageExt Wrap-up
- Either monad, Either
- memoization, Memoization
- None for null, Option
- Option as a Maybe, Option-Option
- Filter() as a Where(), Option
- Fold() for aggregation, Option
- Iter() as a kind of Tap(), Option
- Match() function instead of switch, Option
- MatchUnsafe() allowing null to be returned, Option
- Reader, Reader
- State monad, State
- using static LanguageExt.Prelude, LanguageExt
- lazy evaluation
- Learn You a Haskell for Great Good! (Lipovača), Pure Functional Languages, Pure Functional Languages
- left identity law for monads, Left Identity Law
- LINQ in C#
- about, A Functional Film Query
- added to C#, Multiparadigm Languages
- .All to evaluate lambda expression against enumerables, A Super-Simple Validator
- .Any to evaluate enumerable elements, Funcs in Enumerables
- efficiency of pure LINQ operations, What Does All of This Mean?
- expressions rather than statements, Preferring Expressions to Statements
- first functional code, A Functional Film Query
- (see also getting started)
- FirstOrDefault to iterate through functions, Pattern Matching for Old Versions of C#
- indefinite iterators, Using Indefinite Iterators-Using Indefinite Iterators
- SelectMany(), No starting array, Nested Maybes
- LINQPad playground, Taking It Further: Develop Your Functional Skills
- Lipovača, Miran, Pure Functional Languages, Pure Functional Languages
- List
- LISt Processor (LISP), Where Does Functional Programming Come From?
- logging
- loops
- aggregating many into a single value, Many to One: The Subtle Art of Aggregation-Many to One: The Subtle Art of Aggregation
- do not concatenate strings in for loops, Immutability
- enumerables, Understanding Enumerables
- for loops as noise in signal-to-noise ratio, Reduced Code Noise
- functional code predictability, Predictable
- indefinite loops
- about, Indefinite Loops
- custom iterator, Custom Iterator-Using Indefinite Iterators
- goto command, Trampolining
- indefinite iterators used, Using Indefinite Iterators-Using Indefinite Iterators
- Martian Trail game, Technical Detail, The Game Loop-Updating progress
- recursion for, Recursion-Recursion
- Snakes and Ladders game, Indefinite Loops-Indefinite Loops
- tail call optimization, Recursion
- trampolining, Trampolining-Trampolining
- List with foreach to be avoided, The Humble Select
- recursion as, Seriously, recursion, Customized Iteration Behavior
- Select() statement, The Humble Select
- Louth, Paul, LanguageExt
M
- maintainable code, Reduced Code Noise
- Map()
- AutoMapper library Map() function, Map() Versus Bind(), Option
- called Bind() and used with Maybe DU, Maybe, Revisited-Maybe, Revisited
- chaining functions, Chaining Functions-Chaining Functions
- Tap() to inspect at any point, Tap
- composing with, Compose
- as functor, Right Identity Law
- overloaded term in programming, Option
- Martian Trail game
- Maybe something returned DU, Maybe, Functional Flow
- async and, Maybe and Async
- CSharpFunctionalExtensions implementation, Maybe
- logging and, Maybe and Logging-Maybe and Logging
- Maybe with Bind(), Maybe, Revisited-Maybe, Revisited
- as monad, Other Structures
- Option in LanguageExt, Option-Option
- Result versus, Maybe Versus Result-Maybe Versus Result
- State monad with, Maybe a State?
- McCarthy, John, Where Does Functional Programming Come From?
- McIntyre, Harry, Discriminated Unions, OneOf
- median calculation, Many to One: The Subtle Art of Aggregation
- memoization
- metadata objects for error logging, Try/Catch
- methods
- modules and functional C#, How Should I Structure a Functional C# Solution?
- monads
- about, Maybe, Revisited, Right Identity Law
- enumerables as, Enumerable
- Environment monad, Other Structures
- example, A Worked Example-A Worked Example
- Identity monad, Other Structures
- IO monad, Other Structures
- laws
- Maybe DU and logging, Maybe and Logging-Maybe and Logging
- Maybe DU as, Other Structures
- Maybe DU with Bind(), Maybe, Revisited-Maybe, Revisited
- Maybe monad of Functional.Maybe, Functional.Maybe-Functional.Maybe
- Reader monad for database connection, Reader-Reader
- mock IDbConnection unit tests, Reader
- State monad, State-State, Other Structures
- tasks as, Task
- Mr. Bunny’s Big Cup o’ Java (Egremont), What Kind of Day Has It Been?
- multiparadigm languages, Multiparadigm Languages
- mutability (see immutability)
N
- names processed into First, Last, array of Middles, Pattern Matching in C# 11
- .NET
- assuming Framework 3.5, What Can We Do Already?
- currying, Currying in .NET
- F# and C# compiling to same IL, Interop with F# performance
- F# as .NET language, What About F#? Should I Be Learning F#?
- F# code referenced in C#, Interop with F# performance-Interop with F# performance
- F# common runtime with C#, Preface, Active Patterns
- F# library interoperability with C#, Multiparadigm Languages
- learning C#, Preface
- partial application, Partial Application in .NET
- programmers’ playground site, Taking It Further: Develop Your Functional Skills
- Newell, Allen, Where Does Functional Programming Come From?
- NuGet packages
- null values
- nullable reference types, Nullable Reference Types-Nullable Reference Types
P
- parameters
- parsing values with extension methods, Parsing Values
- partial application, Partial Application-Partial Application
- password validator code example, A Super-Simple Validator-A Super-Simple Validator
- pattern matching
- performance of functional C#
- Person class names, Pattern Matching in C# 11, Naming Conventions-Naming Conventions
- predictable flow of code, Predictable
- primitive types, Maybe and the Primitives
- problem report showing need for higher-order functions, A Problem Report-A Problem Report
- procedural programming
- programming paradigms
- Project Euler code challenge site, Taking It Further: Develop Your Functional Skills
- project properties and compiler option for nullable reference types, Nullable Reference Types-Nullable Reference Types
- pure functional languages, Who Else Does Functional Programming?-What About F#? Should I Be Learning F#?
- pure functions, Referential transparency
- PureScript as pure functional language, Pure Functional Languages
- Python as multiparadigm language, Multiparadigm Languages
R
- “Railway Oriented Programming” (Wlaschin), Maybe, Revisited
- RAM costs versus FP costs, What Does All of This Mean?
- Ramda (JavaScript library) composing features, Compose
- random number generator, Query Adjacent Elements
- Rawitsch, Don, The Martian Trail
- read-only structs, Read-Only Structs
- Reader monad for database connection, Reader-Reader
- LanguageExt implementation, Reader
- mock IDbConnection unit tests, Reader
- record types, Record Types-Record Types
- recursion
- referential transparency as FP property, Referential transparency-Referential transparency
- resources
- books that cover F#, Active Patterns
- Essential F# (Russell), Active Patterns, Learn F#
- Functional Programming in C# (Buonanno), Acknowledgments, More Functional C#
- Get Programming with F# (Abraham), Learn F#
- JavaScript: The Good Parts (Crockford), Multiparadigm Languages
- Learn You a Haskell for Great Good! (Lipovača), Pure Functional Languages, Pure Functional Languages
- online
- “Applying Functional Principles in C# 6” (Khorikov), CSharpFunctionalExtensions
- author website, What About You?
- book web page, How to Contact Us
- code challenge sites, Taking It Further: Develop Your Functional Skills, Functional C# and Performance
- Daleks on Doctor Who, Handling Nulls
- discriminated unions in NuGet packages, Discriminated Unions
- F# for Fun and Profit (Wlaschin), Active Patterns, Learn F#
- Functional Core, Imperative Shell (Bernhardt), Referential transparency
- “Functional Techniques for C#” (Dollard), Acknowledgments
- Functional.Maybe library, Functional.Maybe
- how to write high-performance C#, What If There’s No Way to Make a Bit of Code as
High-Performant as I’d Like with Functional-Style Code?
- JavaScript: The Good Parts (Crockford lecture), Multiparadigm Languages
- LanguageExt NuGet package, LanguageExt
- Learn You a Haskell for Great Good! (Lipovača), Pure Functional Languages
- Martian Trail game source code, Creating the Game, Summary
- .NET playground for programmers, Taking It Further: Develop Your Functional Skills
- OneOf NuGet package, Discriminated Unions, OneOf
- “Railway Oriented Programming” (Wlaschin), Maybe, Revisited
- Ramda JavaScript library, Compose
- SOLID principles, Thunks
- Sundew.DiscriminatedUnions, Discriminated Unions
- Usborne Publishing game source code, The Martian Trail
- Result DU, Result
- return types
- right identity law for monads, Right Identity Law
- robust code via functional programming, Robust
- Rock, Paper, Scissors game, Pattern Matching in C# 8
- Rufus, William, Bacon Numbers
- Russell, Ian, What About F#? Should I Be Learning F#?, Active Patterns, Learn F#
S
- Schönfinkel, Moses, Where Does Functional Programming Come From?
- Schrödinger, Erwin, Schrödinger’s Union
- Scissors, Paper, Stone game, Pattern Matching in C# 8
- seed for Aggregate() (LINQ), Many to One: The Subtle Art of Aggregation
- Seemann, Mark, Expressions rather than statements
- Select()
- SelectMany() (LINQ), No starting array, Nested Maybes
- sending email via discriminated unions, Sending Email
- Seq as F# equivalent to IEnumerable, Interop with F# performance
- serverless software, Better Support for Concurrency
- setters, init-only, Init-Only Setters
- Shaw, Cliff, Where Does Functional Programming Come From?
- signal-to-noise ratio of code, Reduced Code Noise
- Simon, Herbert, Where Does Functional Programming Come From?
- Snakes and Ladders game
- SOLID principles of OOP, Thunks
- SQL (Structured Query Language) as declarative programming paradigm, Is It a Language, an API, or What?
- SQL Server database and Reader monad, Reader-Reader
- mock IDbConnection unit tests, Reader
- stack overflow possibility with recursion, Recursion
- state
- State monads, State-State, Other Structures
- statements defined, Expressions rather than statements
- string.Join as aggregation, Iterator value is required, Funcs in Enumerables
- structs
- structs, read-only, Read-Only Structs
- Structured Query Language (SQL) as declarative programming paradigm, Is It a Language, an API, or What?
- Sum() (LINQ), Many to One: The Subtle Art of Aggregation
- Sundew.DiscriminatedUnions (Hugener-Olsen), Discriminated Unions
- switch
- default case via _ discard character, Pattern Matching in C# 8
- expression C# 8 and later, Pattern Matching in C# 8
- pattern matching
- about, Pattern matching, Pattern Matching
- active patterns in F#, Active Patterns
- bank account procedural example, Procedural Bank Accounts-Procedural Bank Accounts
- C# 7 pattern matching, Pattern Matching in C# 7-Pattern Matching in C# 7
- C# 8 pattern matching, Pattern Matching in C# 8
- C# 9 pattern matching, Pattern Matching in C# 9
- C# 10 pattern matching, Pattern Matching in C# 10
- C# 11 pattern matching, Pattern Matching in C# 11
- discriminated unions, Discriminated Unions
- (see also discriminated unions)
- old versions of C#, Pattern Matching for Old Versions of C#-Pattern Matching for Old Versions of C#
- validator code example, A Super-Simple Validator-A Super-Simple Validator
- two dots (..) in expression, Pattern Matching in C# 11
T
- tail recursion, Recursion
- Tap() to inspect chains of functions, Tap
- tasks as monads, Task
- Tennant, David, Bacon Numbers
- test-driving development (TDD), Testable
- testing
- text-based adventure game, Pattern Matching in C# 11
- thunks, Thunks-Thunks
- Tibb’s Frankie from Shivaji Park, Mumbai, Currying and Partial Application
- ToArray()
- ToList()
- Torgerson, Mads, Preface
- trampolining, Trampolining-Trampolining
- transducers, Transduce
- travel agency system for package holidays
- try/catch blocks, Try/Catch-Try/Catch
- Tsvetkov, Andrey, Functional.Maybe
- tuples, Tuples
- two dots (..) in switch expression, Pattern Matching in C# 11
W
- warnings in IDE and compiler option for nullable reference types, Nullable Reference Types-Nullable Reference Types
- web page for this book, How to Contact Us
- website for author, What About You?
- where to go from here
- Where() and transducers, Transduce
- with (keyword of record types), Record Types
- Wlaschin, Scott, Active Patterns, Maybe, Revisited, Learn F#
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.