Hands-On F# Application Development

This video gives an overview of entire course.

Setting up F# is different in VS 2017 than in earlier versions. This video shows how to get the tools ready.

• Install F# tools from Visual Studio Setup program

• Create F# projects and test code in interactive window

• Subscribe to get new features in F# nightly builds

VS Code is fast, free, and cross platform, but using F# is quite different from Visual Studio. This video shows how to install and use the Ionide F# tools.

• Install Ionide extensions

• Create F# files and folders

• Use the F# features in editor and interactive window

VS Code and Ionide rely on open source FAKE and Paket tools to make projects compile into assemblies. The experience is very different from Visual Studio, but this video shows how to do it.

• Use Ionide to create F# project files

• Use Paket to manage packages and FAKE to build assemblies

• Add a reference to a project from another project

This video shows how to write and run unit tests in F# in Visual Studio using MSTest, NUnit, and XUnit.

• Install MSBuild and create unit tests

• Install NUnit and create unit tests

• Install XUnit and create unit tests

You can write better tests faster if you use functional testing libraries designed just for F#. This video shows how to do that.

• Install FSUnit. Extra work needed because of Nuget package dependencies

• Install Unquote and use its unique assertion syntax

• Compare advantages of FSUnit and UnQuote

In this video, we will understand why IDTs are preferred over classes for functional programming. Know when to use each type of IDT.

• Understand what IDTs have in common

• Understand when to use tuples and records

• Understand when to use discriminated unions and options

In this video, we will use the five types of collections in F# to model groups of objects and also will understand when and how to use each type.

• Learn the common features of the five collection types, and the special features of each

• Instantiate and use the sequential collection types –Array, List, and Seq

• Instantiate and use the hash table collection types – Set and Map

In this video, we will compose your application out of small, easily testable parts avoiding bloat.

• Understand the syntax for writing functions, and what a function’s type declaration means

• Use F#’s power to return functions from functions and to take functions as arguments to other functions

• Review how and when to use anonymous functions

In this video, we will leverage the ready-made collection functions in F# to do complex processing on large amounts of data without writing a lot of code.

• Use query functions to efficiently extract information from collections efficiently

• Generate new collections from existing ones with Map, Filter, and Rev functions

• Calculate complex results with Fold and Reduce functions

In this video, we will see how to make functional F# programs interoperate with programs written in non-functional, object-oriented .NET languages like C#.

• Consume C# class libraries in F#

• Expose F# modules and functions to C#

• Expose F# IDTs to C# and understand the limitations

In this video, we will see how to accurately model and implement the required behavior to design good software. Object-oriented approaches to design often focus on data before behavior. But the functional features of F# and its interactive prototyping, let you model and implement behavior from the beginning.

• Represent the required behavior with F# functions

• Declare types for the arguments and return values of functions

• Elaborate your types as you discover what data they need

F# units of measure turn numeric values into domain-specific types. In this video, we will see that with UoMs you can easily tell what a numeric value represents in the real world. Even better, a UoM can only be used for correct purposes in calculations.

• Discover what UoMs are required by your domain

• Declare UoMs for numeric types

• Implement transformations between UoM types, if necessary

Whereas UoMs are for numbers. In this video, we will see that how single-valued unions let you turn any .NET type – including strings, DataTimes, and bools into a domain-specific type. SCUs make clear what a value means in the real world, and what things it can be used for.

• Understand the benefits of single-case discriminated unions (SCUs)

• Declare SCUs from built-in .NET types

• Learn how to extract the value from a SCU

Bugs won’t happen at runtime if they keep the program from compiling. In this video, we’ll see how to use F#’s type system to make invalid runtime conditions unrepresentable.

• Use F# types to model valid states only

• Use functions to allow only valid state transitions

• Encapsulate object creation behind F# modules

A pure function is one with no side effects. This video will show how to use pure functions to improve both the expressiveness and safety of your code.

• Understand why pure functions make code more expressive and safe

• Learn to recognize when a function is impure

• Learn techniques to make functions pure and avoid impurity

Dependency injection is a common way to make code more extensible and testable. In object oriented languages, dependency injection is usually implemented with interfaces. In this video, we will see how F# lets you implement dependency injection easily and with less ceremony by using higher order functions.

• Compare dependency injection using interfaces with F#’s higher order functions

• Understand why functions used in dependency injection should be pure

• Use function type definitions to define what behavior to inject

Sometimes all the data a function needs isn’t available at once. This video shows how classes are often used in object oriented programming to solve this problem, and F# partial functions are a more straightforward solution.

• Use partial functions to capture available arguments while deferring others

• Understand the effect of tuple arguments on partial function construction

• Arrange the order of arguments to facilitate partial function application

In OOP, it’s often easier for an object to call its own methods than to call methods on other objects. This encourages creating large bloated classes. In this video, will see that F# functions can call other functions easily. , And that’s why complex behaviors can be composed out of the simpler behavior of individual functions.

• Use the |> and >> operators for function composition

• Understand why functions used in composition should be pure

• Understand the effect of tuple arguments on function composition

In OOP, it’s easy to define a class’s data, but more difficult to enforce data validity rules, and still more difficult to enforce state transition rules. In this video, we will see how with F# it’s easy to define state transitions, even before you define all the data for each state.

• Learn the data and function patterns for state transitions

• Use functions to define state transition rules

• Define the data types that represent each state