7. Advanced Techniques: Functions Revisited | F# 4.0 Design Patterns

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

F# 4.0 Design Patterns

By : Gene Belitski

3.5 (4)

F# 4.0 Design Patterns

3.5 (4)

By: Gene Belitski

Overview of this book

Following design patterns is a well-known approach to writing better programs that captures and reuses high-level abstractions that are common in many applications. This book will encourage you to develop an idiomatic F# coding skillset by fully embracing the functional-first F# paradigm. It will also help you harness this powerful instrument to write succinct, bug-free, and cross-platform code. F# 4.0 Design Patterns will start off by helping you develop a functional way of thinking. We will show you how beneficial the functional-first paradigm is and how to use it to get the optimum results. The book will help you acquire the practical knowledge of the main functional design patterns, the relationship of which with the traditional Gang of Four set is not straightforward. We will take you through pattern matching, immutable data types, and sequences in F#. We will also uncover advanced functional patterns, look at polymorphic functions, typical data crunching techniques, adjusting code through augmentation, and generalization. Lastly, we will take a look at the advanced techniques to equip you with everything you need to write flawless code.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Begin Thinking Functionally

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

2. Dissecting F# Origins and Design

The evolvement of F#

Predecessor inherited language features

.NET-imposed language features

Intrinsic F# language features

Summary

3. Basic Functions

3. Basic Functions

The notion of function in F#

Function parameters and arguments

Higher-order functions

Closures

Type inference

Recursive function basics

Operators as functions

Function composition

Summary

4. Basic Pattern Matching

4. Basic Pattern Matching

An explicit form of pattern matching with match construction

Matching literals

Wildcard matching

Arranging matching rules

Named patterns

The as pattern

Grouping patterns

Guards

The alternative syntax for anonymous function performing matching

Summary

5. Algebraic Data Types

5. Algebraic Data Types

Combining data with algebraic data types

Product algebraic data types

Sum algebraic data types

Summary

6. Sequences - The Core of Data Processing Patterns

6. Sequences - The Core of Data Processing Patterns

Basic sequence transformations

The sequence: Duality of data and calculation

Sequence of an indefinite length as a design pattern

Sequence and the code performance

Summary

7. Advanced Techniques: Functions Revisited

7. Advanced Techniques: Functions Revisited

A deep dive into recursion

Folding

Memoization

Lazy evaluation

Continuation passing style

Active patterns

Summary

8. Data Crunching – Data Transformation Patterns

8. Data Crunching – Data Transformation Patterns

Core data transformation libraries in F# 4.0

Data transformation patterns

Summary

9. More Data Crunching

9. More Data Crunching

Data querying

Data parsing

Summary

10. Type Augmentation and Generic Computations

10. Type Augmentation and Generic Computations

Code generalization

Type augmentation

Summary

11. F# Expert Techniques

11. F# Expert Techniques

A note on custom computation expressions

Exploring type providers

Exploring concurrent computations

Exploring reactive computations

Exploring quotations and metaprogramming

Summary

12. F# and OOP Principles/Design Patterns

12. F# and OOP Principles/Design Patterns

Morphing SOLID principles

Diminishing patterns

Summary

13. Troubleshooting Functional Code

13. Troubleshooting Functional Code

Why idiomatic F# admits less defects

Using REPL and the explorative programming style

Addressing some compile-time problems

Addressing run-time problems

Summary

Folding

Now is the perfect time to revisit the factorial function that I used at the beginning of this chapter when covering tail recursion. Let's take a sequence of bigint numbers from 1I to a value n represented by the following expression:

Seq.init (n + 1) bigint.op_Implicit |> Seq.skip 1

Does the factorial(n) function represent nothing else but a product of the factors, each being a member of the preceding sequence? Sure, it can be seen (and implemented) as such. Let me create this implementation in the best traditions of the imperative programming style as shown here (Ch7_3.fsx):

let ``folding factorial (seq)`` n = 
  let fs = Seq.init (n + 1) bigint.op_Implicit |> Seq.skip 1 
  use er = fs.GetEnumerator() 
  let mutable acc = 1I 
  while er.MoveNext() do 
    acc <- acc * er.Current 
  acc

Expressed in plain words, this implementation can be laid out in the following manner:

Take a mutable value that will serve as a result accumulator
Enumerate the sequence of factors
For each...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

F# 4.0 Design Patterns

Search

Your notes and bookmarks