- F# 4.0 Design Patterns
- F# 4.0 Design Patterns
- Credits
- About the Author
- Acknowledgements
- About the Reviewer
- www.PacktPub.com
- Preface
- 1. Begin Thinking Functionally
- Relationship between F# and programming paradigms
- A sample problem to solve
- Immutability of participating data entities
- Thinking in verbs rather than nouns
- "What" prevailing over "how"
- Generalization over specialization
- Minimizing moving parts over hiding them
- Reduction to known parts over producing custom parts
- Lazy over eager data collections
- Summary
- 2. Dissecting F# Origins and Design
- The evolvement of F#
- Predecessor inherited language features
- F# functions are first-class entities
- Functions are free of side effects
- Functions can be curried and partially evaluated
- Functions may be anonymous
- Functions may be recursive
- Functions may raise exceptions
- Functions may reference external values
- F# is a statically typed language
- F# type inference provides type generalization
- F# supports parametric polymorphism
- F# inherits the variety of aggregate data structures from ML
- F# supports pattern matching
- F# supports data references
- Functions are non-recursive by default
- Modules
- .NET-imposed language features
- F# adheres to .NET Common Language Infrastructure
- F# has nominal type system
- F# fully embraces .NET object orientation
- F# requires calling the method of an explicit interface
- Object expressions
- Reflection
- Extending classes and modules
- Enumerations
- Structures
- Events
- Nullable types
- Interoperation with the managed code
- Interoperation with unmanaged code
- Intrinsic F# language features
- Summary
- 3. Basic Functions
- 4. Basic Pattern Matching
- 5. Algebraic Data Types
- 6. Sequences - The Core of Data Processing Patterns
- 7. Advanced Techniques: Functions Revisited
- 8. Data Crunching – Data Transformation Patterns
- Core data transformation libraries in F# 4.0
- Data transformation patterns
- The generation pattern
- The aggregation pattern
- The wrapping and type conversion pattern
- The selection pattern
- The searching pattern
- The partitioning pattern
- The reordering pattern
- The testing pattern
- The iterating pattern
- The mapping pattern
- The folding pattern
- The merge/split pattern
- Summary
- 9. More Data Crunching
- 10. Type Augmentation and Generic Computations
- 11. F# Expert Techniques
- 12. F# and OOP Principles/Design Patterns
- 13. Troubleshooting Functional Code
This chapter highlighted that the functional-first approach does not blindly contradicts principles and patterns of object-oriented programming. Sometimes it also supports and amplifies them.
I'm going to devote the final chapter of this book to the subject of troubleshooting functional-first code, as it has certain specifics.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.