- 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
I expect that this chapter moved your intuition in the direction of a handful of notions the functional-first nature of F# is based upon.
Recognizing and distilling these cornerstones from any relevant code context, you are now ready to absorb the main contents. In the next chapter, I'll turn to the cornerstone of F# programming techniques that is present in literally every data transformation, that is, Pattern Matching.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.