Real World Functional Programming: With Examples in F# and C#

Front cover......Page 1
Quick Reference – Functional Programming Concepts......Page 2
brief contents......Page 7
contents......Page 9
foreword......Page 19
preface......Page 21
acknowledgments......Page 23
about this book......Page 26
What won’t this book give you?......Page 27
Roadmap......Page 28
Naming conventions......Page 29
Author Online......Page 30
Other online resources......Page 31
about the cover illustration......Page 32
Learning to think functionally......Page 33
Thinking differently......Page 35
1.1 What is functional programming?......Page 36
1.2.1 Functional languages......Page 38
1.3.1 The functional paradigm......Page 39
1.3.2 Declarative programming style......Page 40
1.3.3 Understanding what a program does......Page 41
1.3.4 Concurrency-friendly application design......Page 42
1.3.5 How functional style shapes your code......Page 43
1.4 Functional programming by example......Page 44
1.4.1 Expressing intentions using declarative style......Page 45
1.4.2 Understanding code using immutability......Page 49
1.4.3 Writing efficient parallel programs......Page 52
1.5 Introducing F#......Page 53
1.5.1 Hello world in F#......Page 54
1.5.2 From simplicity to the real world......Page 56
1.6 Summary......Page 59
Core concepts in functional programming......Page 61
2.1 The foundation of functional programming......Page 63
2.2 Evaluation of functional programs......Page 64
2.2.2 Using immutable data structures......Page 65
2.2.3 Changing program state using recursion......Page 66
2.2.4 Using expressions instead of statements......Page 67
2.2.5 Computation by calculation......Page 69
2.3.1 Functions as values......Page 71
2.3.2 Higher-order functions......Page 73
2.4 Functional types and values......Page 77
2.4.1 Type inference in C# and F#......Page 78
2.4.2 Introducing the discriminated union type......Page 79
2.4.3 Pattern matching......Page 80
2.4.4 Compile-time program checking......Page 83
2.5 Summary......Page 84
Meet tuples, lists, and functions in F# and C#......Page 86
3.1.1 Value declarations and scope......Page 87
3.1.2 Function declarations......Page 89
3.1.3 Declaring mutable values......Page 91
3.2.1 Introducing tuple type......Page 92
3.2.2 Implementing a tuple type in C#......Page 95
3.2.3 Calculating with tuples......Page 96
3.2.4 Pattern matching with tuples......Page 98
3.3.1 Recursive computations......Page 100
3.3.2 Introducing functional lists......Page 101
3.3.3 Functional lists in C#......Page 104
3.3.4 Functional list processing......Page 106
3.4 Using functions as values......Page 107
3.4.1 Processing lists of numbers......Page 108
3.5 Summary......Page 111
Exploring F# and .NET libraries by example......Page 113
4.1 Drawing pie charts in F#......Page 114
4.2.1 Loading and parsing data......Page 115
4.2.2 Calculating with the data......Page 118
4.3 Creating a console application......Page 121
4.4.1 Creating the user interface......Page 124
4.4.2 Drawing graphics......Page 127
4.4.3 Creating the Windows application......Page 133
4.5 Summary......Page 134
Fundamental functional techniques......Page 137
Using functional values locally......Page 139
5.1.1 Primitive types, value types, and objects......Page 140
5.2.1 Multiple values in F# and C#......Page 141
5.2.2 Tuple type and value constructors......Page 143
5.2.3 Using tuples compositionally......Page 144
5.3 Alternative values......Page 146
5.3.1 Discriminated unions in F#......Page 147
5.3.2 Working with alternatives......Page 148
5.3.3 Adding types vs. functions......Page 150
5.3.4 Using the option type in F#......Page 152
5.4.1 Implementing the option type in C#......Page 154
5.4.2 Generic option type in F#......Page 157
5.4.3 Type inference for values......Page 159
5.4.4 Writing generic functions......Page 161
5.5 Function values......Page 162
5.5.1 Lambda functions......Page 164
5.5.2 The function type......Page 167
5.5.3 Functions of multiple arguments......Page 169
5.6 Summary......Page 172
Processing values using higher-order functions......Page 174
6.1 Generic higher-order functions......Page 175
6.1.1 Writing generic functions in F#......Page 176
6.1.2 Custom operators......Page 177
6.2.1 Working with tuples using functions......Page 179
6.2.2 Methods for working with tuples in C#......Page 182
6.3 Working with schedules......Page 183
6.3.1 Processing a list of schedules......Page 184
6.3.2 Processing schedules in C#......Page 185
6.4 Working with the option type......Page 186
6.4.2 Using the bind function......Page 187
6.4.3 Evaluating the example step-by-step......Page 188
6.4.4 Implementing operations for the option type......Page 190
6.5.1 Function composition......Page 192
6.5.2 Function composition in C#......Page 194
6.6.1 Type inference for function calls in F#......Page 195
6.6.2 Automatic generalization......Page 196
6.7.1 Implementing list in F#......Page 197
6.7.2 Understanding type signatures of list functions......Page 198
6.7.3 Implementing list functions......Page 202
6.8.1 Mapping, filtering, and folding......Page 205
6.8.2 The bind operation for lists......Page 206
6.9 Summary......Page 207
Designing data-centric programs......Page 209
7.1 Functional data structures......Page 210
7.1.1 Using the F# record type......Page 211
7.1.2 Functional data structures in C#......Page 213
7.2 Flat document representation......Page 214
7.2.1 Drawing elements......Page 215
7.2.2 Displaying a drawing on a form......Page 216
7.3 Structured document representation......Page 219
7.3.1 Converting representations......Page 220
7.3.2 XML document representation......Page 223
7.4 Writing operations......Page 226
7.4.1 Updating using a map operation......Page 227
7.4.2 Calculating using an aggregate operation......Page 230
7.5 Object-oriented representations......Page 231
7.5.1 Representing data with structural patterns......Page 232
7.5.2 Adding functions using the visitor pattern......Page 234
7.6 Summary......Page 236
Designing behavior-centric programs......Page 237
8.1.1 Representing behaviors as objects......Page 238
8.1.2 Representing behaviors as functions in C#......Page 239
8.1.3 Using collections of functions in C#......Page 240
8.1.4 Using lists of functions in F#......Page 241
8.2 Idioms for working with functions......Page 243
8.2.1 The strategy design pattern......Page 244
8.2.2 The command design pattern......Page 245
8.2.3 Capturing state using closures in F#......Page 247
8.3.1 Records of functions......Page 251
8.3.2 Building composed behaviors......Page 253
8.3.3 Further evolution of F# code......Page 254
8.4.1 Decision trees......Page 255
8.4.2 Decision trees in F#......Page 256
8.4.3 Decision trees in C#......Page 259
8.5 Summary......Page 261
Advanced F# programming techniques......Page 263
Turning values into F# object types with members......Page 265
9.1 Improving data-centric applications......Page 266
9.1.1 Adding members to F# types......Page 267
9.1.2 Appending members using type extensions......Page 270
9.2.1 Using records of functions......Page 272
9.2.2 Using interface object types......Page 273
9.3 Working with .NET interfaces......Page 275
9.3.1 Using .NET collections......Page 276
9.3.2 Cleaning resources using IDisposable......Page 277
9.4 Concrete object types......Page 280
9.4.1 Functional and imperative classes......Page 281
9.4.2 Implementing interfaces and casting......Page 283
9.5 Using F# libraries from C#......Page 287
9.5.1 Working with records and members......Page 288
9.5.2 Working with values and delegates......Page 290
9.6 Summary......Page 291
Efficiency of data structures......Page 292
10.1.1 Avoiding stack overflows with tail recursion......Page 293
10.1.2 Caching results using memoization......Page 298
10.2.1 Avoiding stack overflows with tail recursion (again!)......Page 303
10.2.2 Processing lists efficiently......Page 305
10.2.3 Working with arrays......Page 307
10.3.1 What makes tree processing tricky?......Page 311
10.3.2 Writing code using continuations......Page 313
10.4 Summary......Page 315
Refactoring and testing functional programs......Page 317
11.1 Refactoring functional programs......Page 318
11.1.1 Reusing common code blocks......Page 319
11.1.2 Tracking dependencies and side effects......Page 321
11.2 Testing functional code......Page 324
11.2.1 From the interactive shell to unit tests......Page 325
11.2.2 Writing tests using structural equality......Page 328
11.2.3 Testing composed functionality......Page 331
11.3 Refactoring the evaluation order......Page 332
11.3.1 Different evaluation strategies......Page 333
11.3.2 Comparing evaluation strategies......Page 334
11.3.3 Simulating lazy evaluation using functions......Page 335
11.3.4 Lazy values in F#......Page 336
11.3.5 Implementing lazy values for C#......Page 338
11.4 Using lazy values in practice......Page 339
11.4.1 Introducing infinite lists......Page 340
11.4.2 Caching values in a photo browser......Page 342
11.5 Summary......Page 345
Sequence expressions and alternative workflows......Page 346
12.1 Generating sequences......Page 347
12.1.2 Using iterators in C#......Page 348
12.1.3 Using F# sequence expressions......Page 349
12.2.1 Recursive sequence expressions......Page 352
12.2.2 Using infinite sequences......Page 354
12.3 Processing sequences......Page 357
12.3.1 Transforming sequences with iterators......Page 358
12.3.2 Filtering and projection......Page 359
12.3.3 Flattening projections......Page 361
12.4 Introducing alternative workflows......Page 366
12.4.1 Customizing query expressions......Page 367
12.4.2 Customizing the F# language......Page 368
12.5.1 Declaring the computation type......Page 370
12.5.2 Writing the computations......Page 371
12.5.3 Implementing a computation builder in F#......Page 372
12.5.4 Implementing query operators in C#......Page 374
12.6 Implementing computation expressions for options......Page 375
12.7.1 Creating the logging computation......Page 378
12.7.2 Creating the logging computation......Page 379
12.7.3 Refactoring using computation expressions......Page 381
12.8 Summary......Page 382
Applied functional programming......Page 383
Asynchronous and data-driven programming......Page 385
13.1.1 Why do asynchronous workflows matter?......Page 386
13.1.2 Downloading web pages asynchronously......Page 387
13.1.3 Understanding how workflows work......Page 390
13.1.4 Creating primitive workflows......Page 393
13.2 Connecting to the World Bank......Page 394
13.2.1 Accessing the World Bank data......Page 395
13.2.2 Recovering from failures......Page 397
13.3.1 Implementing XML helper functions......Page 398
13.3.2 Extracting region codes......Page 400
13.3.3 Obtaining the indicators......Page 401
13.4.1 Reading values......Page 404
13.4.2 Formatting data using units of measure......Page 406
13.4.3 Gathering statistics about regions......Page 409
13.5.1 Writing data to Excel......Page 410
13.5.2 Displaying data in an Excel chart......Page 413
13.6 Summary......Page 414
Writing parallel functional programs......Page 415
14.1 Understanding different parallelization techniques......Page 416
14.1.1 Parallelizing islands of imperative code......Page 417
14.1.2 Declarative data parallelism......Page 418
14.1.3 Task-based parallelism......Page 422
14.2.1 Calculating with colors in F#......Page 427
14.2.2 Implementing and running color filters......Page 428
14.2.3 Designing the main application......Page 431
14.2.4 Creating and running effects......Page 433
14.2.5 Parallelizing the application......Page 436
14.2.6 Implementing a blur effect......Page 438
14.3 Creating a parallel simulation......Page 440
14.3.1 Representing the simulated world......Page 441
14.3.2 Designing simulation operations......Page 443
14.3.3 Implementing helper functions......Page 445
14.3.4 Implementing smart animals and predators......Page 447
14.3.5 Running the simulation in parallel......Page 449
14.4 Summary......Page 451
Creating composable functional libraries......Page 452
15.1.1 Composing animations from symbols......Page 453
15.1.2 Giving meaning to symbols......Page 454
15.1.3 Composing values......Page 456
15.1.4 Composing functions and objects......Page 457
15.2.1 Introducing functional animations......Page 460
15.2.2 Introducing behaviors......Page 461
15.2.3 Creating simple behaviors in C#......Page 463
15.2.4 Creating simple behaviors in F#......Page 465
15.3.1 Reading values......Page 466
15.3.2 Applying a function to a behavior......Page 467
15.3.3 Turning functions into “behavior functions”......Page 468
15.3.4 Implementing lifting and map in C#......Page 470
15.4.1 Representing drawings......Page 472
15.4.2 Creating and composing drawings......Page 474
15.5 Creating animations......Page 477
15.5.1 Implementing the animation form in F#......Page 478
15.5.2 Creating animations using behaviors......Page 480
15.5.3 Adding animation primitives......Page 481
15.5.4 Creating a solar system animation......Page 484
15.6 Developing financial modeling language......Page 486
15.6.2 Defining the primitives......Page 487
15.6.3 Using the modeling language......Page 489
15.7 Summary......Page 491
Developing reactive functional programs......Page 492
16.1 Reactive programming using events......Page 493
16.1.1 Introducing event functions......Page 494
16.1.2 Using events and observables......Page 495
16.1.3 Creating a simple reactive application......Page 498
16.1.4 Declarative event processing using LINQ......Page 499
16.1.5 Declaring events in F#......Page 502
16.2 Creating reactive animations......Page 503
16.2.1 Using the switch function......Page 504
16.2.2 Implementing the switch function......Page 505
16.3.1 Waiting for events asynchronously......Page 506
16.3.2 Drawing rectangles......Page 509
16.4.1 Working with state safely......Page 512
16.4.2 Creating a mailbox processor......Page 513
16.4.3 Communicating using messages......Page 515
16.4.4 Encapsulating mailbox processors......Page 519
16.4.5 Waiting for multiple events......Page 520
16.5 Message passing concurrency......Page 522
16.5.1 Creating a state machine processor......Page 523
16.5.2 Accessing mailbox concurrently......Page 524
16.6 Summary......Page 525
A.1 What have you learned?......Page 527
A.2 Where do you want to go next?......Page 528
In print......Page 530
In print......Page 531
Online......Page 532
A......Page 533
B......Page 535
C......Page 536
D......Page 539
E......Page 541
F......Page 542
G......Page 544
I......Page 545
J......Page 546
L......Page 547
M......Page 549
N......Page 550
O......Page 551
P......Page 552
Q......Page 553
R......Page 554
S......Page 555
T......Page 558
V......Page 560
Z......Page 561
Quick Reference – F# Language Constructs......Page 562
Back cover......Page 563