F# for C# Programmers

F# for C# programmers
@ScottWlaschin
fsharpforfunandprofit.com

A language that doesn't affect the way you
think about programming, is not worth
knowing – Alan Perlis

“F# is slightly better than C#,
but not so much that it's
really worth the effort to
move towards it.”
“Learning F# was one of the biggest
boosts in my career as a C# developer.
I don't use it professionally (I wish I
could) but this knowledge made me a
better programmer.”

About F#
• Developed by Microsoft Research
– Shipped withVisual Studio in 2010
• Open source
– On github
• Cross platform
– Works withVS Code (and other editors)
• Very active and friendly community.
– Start with fsharp.org
– F# Slack channel
– #fsharp onTwitter

A tour of F#
• Differences between C# and F#
– Concise syntax
– Type inference
– Different defaults
– Different philosophy
• Special to F#
– Functional-first
– Algebraic type system
– Interactivity
From least to most
important!

public class Person
{
public Person(string name, DateTime birthday)
{
_name = name;
_birthday = birthday;
}
private readonly string _name;
private readonly DateTime _birthday;
public string Name
{
get { return _name; }
}
public DateTime Birthday
{
get { return _birthday; }
}
}

Syntax difference:
Indentation instead
of curly braces

public class Person
{
{
_name = name;
}
public string Name
{
}
{
}
}
Do we really need the
braces?
The indentation already gives
us all the clues we need.

public class Person
{
{
_name = name;
}
public string Name
{
}
{
}
}
Example where braces
indicate blocks

public class Person =
public Person(string name, DateTime birthday) =
_name = name;
public string Name =
public DateTime Birthday =
Example where indentation
indicates blocks
Is it really that much
harder to read?

_name = name;
Use '=' to start blocks

_name = name;
Shift up to use less
vertical space

People who
complain about
using a language
with syntactic
whitespace
People who
have spent time
using a language
with syntactic
whitespace
"Oddly enough, Python's use of whitespace stopped feeling unnatural
after about twenty minutes. I just indented code, pretty much as I would
have done in a C program anyway, and it worked."
- Eric Raymond
HelpfulVenn Diagram
Overlap

Syntax difference:
Automatically create
backing fields from
constructor parameters

_name = name;
A lot of duplication...

...
get { return name; }
get { return birthday; }
Use the constructor params directly

Syntax difference:
Merge the primary constructor
with the class definition

...
How often do you have more
than one constructor?

public class Person(string name, DateTime birthday) =

Syntax difference:
Less syntax noise

So why use ‘get’?
The class is immutable.
Every property is "get" only.

return name;
return birthday; 'get' is gone!

return name;
return birthday;
Who even likes typing semicolons anyway?

return name
return birthday
Semicolons gone!

Syntax difference:
No “return” needed

return name
return birthday

name
birthday
F# is an expression-
oriented language

Difference:
Members are public by default

name
birthday

class Person(string name, DateTime birthday) =
string Name =
name
DateTime Birthday =
birthday

string Name =
name
DateTime Birthday =
birthday
Why do we have to
repeat the type?
Can't the compiler
figure it out for us?

Name =
name
Birthday =
birthday

member this.Name =
name
member this.Birthday =
birthday

member this.Name =
name
birthday
member this.Age() =
var daysDiff = DateTime.Today.Subtract(birthday).Days
daysDiff / 365

Syntax difference:
Type annotations

class Person(name: string, birthday: DateTime ) =
member this.Name =
name
birthday
member this.Age() =
var daysDiff = DateTime.Today.Subtract(birthday).Days
daysDiff / 365

Syntax difference:
Different keywords

type Person(name: string, birthday: DateTime ) =
member this.Name =
name
birthday
member this.Age() =
let daysDiff = DateTime.Today.Subtract(birthday).Days
daysDiff / 365

class Person(string name, DateTime birthday)
{
public string Name { get; } = name;
public DateTime Birthday { get; } = birthday;
public int Age() =>
DateTime.Today.Subtract(birthday).Days / 365;
}
Modern C# equivalent with auto-properties
and expression-bodied members

type Person = {
Name: string
Birthday: DateTime
}
let age person =
let daysDiff = DateTime.Today.Subtract(person.Birthday).Days
daysDiff / 365

// age : Person -> int
type Person = {
Name: string
Birthday: DateTime
}
let age person =
let daysDiff = DateTime.Today.Subtract(person.Birthday).Days
daysDiff / 365

Syntax is never the most important
thing about a programming language.
But…

Observation:
21 lines of code has shrunk
to 5 lines of code

You see 3x more
code on your
screen!

public class Person
{
{
_name = name;
}
/// <summary>
/// Full name
/// </summary>
public string Name
{
}
/// <summary>
/// Birthday
/// </summary>
{
}
}
/// Full name
/// Birthday
C#
F#
You write
1/3 as much code.

Type inference
let doSomething f x =
let y = f (x + 1)
"hello" + y

Type inference
let doSomething f x =
let y = f (x + 1)
"hello" + y
Inferred type of doSomething :
f:(int -> string) -> x:int -> string

Type inference
// C# code
public IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
IEnumerable<TSource> source,
Func<TSource, TKey> keySelector
)
{
...
}
// F# code
let GroupBy source keySelector =
...
Benefits of type inference:
* Less typing
* Less noise, more logic
Here's a more complex example

F# has different defaults
• Immutable by default
– mutable is special case
• Non-null types/classes by default
– Nullable is special case
• Structural equality by default
– reference equality is special case
• Everything must be initialized

Mutability
let x = 1
x <- 2 // assign new value

Mutability
let mutable x = 1
x <- 2 // assign new value

Non null
type Person = {
Name: string
Birthday: DateTime
}
let x : Person = null

Non null
[<AllowNullLiteralAttribute>]
type Person(name: string, birthday: DateTime) =
member this.Name = name
member this.Birthday = birthday
let x : Person = null

Structural equality by default
(for record types)

Structural equality
type Person = {
Name: string
Birthday: DateTime
}
let bday = DateTime(1980,1,1)
let alice1 = {Name="Alice"; Birthday=bday}
let alice2 = {Name="Alice"; Birthday=bday}
alice1 = alice2 // true or false?

Everything must be initialized

Initialization
type Person = {
Name: string
Birthday: DateTime
}
let alice : Person

Initialization
type Person = {
Name: string
Birthday: DateTime
}
let alice = {Name="Alice"}

Different philosophies
• C# historically comes from C-like approach.
• F# comes from ML, a MetaLanguage for
proving things.

Goal: Predictable code
• Can you understand the code using only the
information that you have right in front of you?
• You’re not allowed to delve into other parts of
the codebase!

Example 1
The answer is
"hello world".
What value is y?
var x = 1;
DoSomething(x);
var y = "hello " + x;

Example 1
function DoSomething (foo) { x = "world"; }
var x = 1;
DoSomething(x);
var y = "hello " + x;

Predictable code
C# is more predictable than JavaScript!
In C#, if you don't match up the types properly,
you get a compile-time error not a run-time error.
This is good!

How to make your language predictable:
• Variables should not be allowed to change their type

Example 2
// create two customers
var cust1 = new Customer(99, "J Smith");
var cust2 = new Customer(99, "J Smith");
// true or false?
cust1 == cust2;

• Objects with the same values should be equal by
default.

Example 3
// create a customer and an order
var cust = new Customer(99, "J Smith");
var order = new Order(99, "J Smith");
// true or false?
cust.Equals(order);

• Objects with the same values should be equal by
default.
• Comparing objects of different types is a compile-
time error.

Example 4
// create a customer
var cust = new Customer();
// what is the expected output?
Console.WriteLine(cust.Address.Country)

• Objects with the same values should be equal by default.
• Comparing objects of different types is a compile-time error.
• Objects must always be initialized to a valid state. Not doing
so is a compile-time error.

Example 5
var cust = new Customer(99, "J Smith");
// add it to a set
var processedCustomers = new HashSet<Customer>();
processedCustomers.Add(cust);
// process it
ProcessCustomer(cust);
// Is the customer still in the set? True or false?
processedCustomers.Contains(cust);
You can't tell! Not predictable!
If ProcessCustomer mutates the customer, it
might change the hash 

Example 5
var cust = new ImmutableCustomer(99, "J Smith");
// add it to a set
var processedCustomers = new HashSet<ImmutableCustomer>();
processedCustomers.Add(cust);
// process it and return the changes
var changedCustomer = ProcessCustomer(cust);
// Is the customer still in the set? True or false?
processedCustomers.Contains(cust);
Immutability forces
changed values to be
returned explictly. Original
value unchanged.

• Once created, objects and collections must be immutable.

Example 6
// create a repository
var repo = new CustomerRepository();
// find a customer by id
var customer = repo.GetById(42);
// what is the expected output?
Console.WriteLine(customer.Id);
What happens if the customer is missing?
Is the customer null or what?
You can't tell! Not predictable!

Example 6
// create a repository
var repo = new CustomerRepository();
// find a customer by id
var customerOrError = repo.GetById(42);
// handle both cases
if (customerOrError.IsCustomer)
Console.WriteLine(customerOrError.Customer.Id);
if (customerOrError.IsError)
Console.WriteLine(customerOrError.ErrorMessage);
Instead, build error cases into the return type.

• Once created, objects and collections must be immutable.
• Missing data or errors must be made explicit. No nulls
allowed.

F# aims to be a predictable language:
• Variables are not be allowed to change their type
• Objects with the same values are equal by default.
• Objects must be initialized to a valid state. Not doing so is a
compile-time error..
• Once created, objects and collections are (generally)
immutable.
• Missing data or errors are (generally) made explicit. Nulls are
a code smell.

Core principles of functional programming
Function
Parameterize all the things
Functions
Composition everywhere

FP Principle:
Functions are things
Function

Functions as things
The Tunnel of
Transformation
Function
apple -> banana
A function is a thing which
transforms inputs to outputs

Functions as things
let x = 1
let add x y = x + y

A function is a standalone thing,
not attached to a class
It can be used for inputs and outputs
of other functions

input
A function can be an output
of other functions

output
input
A function can be an input
of other functions

output
input
input output
A function can be a parameter
of other functions

output
input
input output
A function can be a parameter
of other functions
From this simple foundation we can build complex systems

FP principle:
Composition everywhere

Function composition
Function 1
apple -> banana
Function 2
banana -> cherry

>>
Function 1
apple -> banana
Function 2
banana -> cherry

New Function
apple -> cherry
Can't tell it was built from
smaller functions!
Where did the banana go?
(abstraction)

add1 double5 12
let add1 x = x + 1
let double x = x + x
let add1_double =
add1 >> double
let x = add1_double 5
Composition (F#)

add1 double square5 144
let add1_double_square =
add1 >> double >> square
let x = add1_double_square 5
Composition (F#)

Func<int, int> add1 = x => x + 1;
Func<int, int> doubl = x => x + x;
Func<int, int> square = x => x * x;
var composed =
add1.Compose(doubl).Compose(square);
composed(5);
Composition (C#)

add1 5 // = 6
double (add1 5) // = 12
square (double (add1 5)) // = 144
5 |> add1 // = 6
5 |> add1 |> double // = 12
5 |> add1 |> double |> square // = 144
Standard way of nesting function calls can be confusing if too deep
add1 double square5 6 12 144

5.Pipe(Add1); // = 6
5.Pipe(Add1).Pipe(Double); // = 12
5.Pipe(Add1).Pipe(Double).Pipe(Square);
Func<int, int> add1 = x => x + 1;
Func<int, int> doubl = x => x + x;
Func<int, int> square = x => x * x;
add1 double square5 6 12 144

Why we say F# is "functional-first"
• F# makes FP easy
• C# makes FP possible
– but it's awkward and not idiomatic

FP Guideline:

let printList() =
for i in [1..10] do
printfn "the number is %i" i

let printList aList =
for i in aList do
printfn "the number is %i" i

let printList anAction aList =
for i in aList do
anAction i
FPers would parameterize the action as well:
We've decoupled the
behavior from the data.
Any list, any action!

public static int Product(int n)
{
int product = 1;
for (int i = 1; i <= n; i++)
{
product *= i;
}
return product;
}
public static int Sum(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
{
sum += i;
}
return sum;
}

let fold action initialValue list =
let mutable totalSoFar = initialValue
for item in list do
totalSoFar <- action totalSoFar item
totalSoFar

let product n =
let initialValue = 1
let action productSoFar x = productSoFar * x
[1..n] |> List.fold action initialValue
let sum n =
let initialValue = 0
let action sumSoFar x = sumSoFar+x
[1..n] |> List.fold action initialValue
Lots of collection functions like this:
"fold", "map", "reduce", "collect", etc.

Big topic! Not enough time right now !
More at fsharpforfunandprofit.com/fppatterns

What are F# types?
A type is not a class

What is a type?
A type is a just a name
for a set of things
Set of
valid inputs
Set of
valid outputs
Function

Set of
valid inputs
Set of
valid outputs
Function
1
2
3
4
5
6
This is type
"integer"
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is type
"string"
"abc"
"but"
"cobol"
"double"
"end"
"float"
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is type
"Person"
Donna Roy
Javier Mendoza
Nathan Logan
Shawna Ingram
Abel Ortiz
Lena Robbins
GordonWood
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is type
"Fruit"
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is a type
containing functions
for a set of things

F# types can be composed
"Algebraic type system"

New types are built from smaller types using:
“AND”
“OR”

Example: pairs, tuples, records
FruitSalad = One each of and and
“AND” types
type FruitSalad = {
Apple: AppleVariety
Banana: BananaVariety
Cherry: CherryVariety
}

Snack = or or
“OR” types
type Snack =
| Apple of AppleVariety
| Banana of BananaVariety
| Cherry of CherryVariety

Real world example
of type composition

Example of some requirements:
We accept three forms of payment:
Cash, Check, or Card.
For Cash we don't need any extra information
For Checks we need a check number
For Cards we need a card type and card number

interface IPaymentMethod
{..}
class Cash() : IPaymentMethod
{..}
class Check(int checkNo): IPaymentMethod
{..}
class Card(string cardType, string cardNo) : IPaymentMethod
{..}
In C# you would probably implement it as an
interface and a set of subclasses, like this:

type CheckNumber = int
type CardNumber = string
In F# you would probably implement by composing
types, like this

type CardType = Visa | Mastercard
type CreditCardInfo = CardType * CardNumber

type PaymentMethod =
| Cash
| Check of CheckNumber
| Card of CreditCardInfo

| Cash
type PaymentAmount = decimal
type Currency = EUR | USD

| Cash
type PaymentAmount = decimal
type Currency = EUR | USD
type Payment = {
Amount : PaymentAmount
Currency: Currency
Method: PaymentMethod }

F# design principle:
Types are executable documentation

type Deal = Deck –› (Deck * Card)
type PickupCard = (Hand * Card) –› Hand
type Suit = Club | Diamond | Spade | Heart
type Rank = Two | Three | Four | Five | Six | Seven | Eight
| Nine |Ten | Jack | Queen | King | Ace
type Card = Suit * Rank
type Hand = Card list
type Deck = Card list
type Player = {Name:string; Hand:Hand}
type Game = {Deck:Deck; Players: Player list}
The domain on one screen!

type CardType =Visa | Mastercard
type CardNumber = CardNumber of string
type CheckNumber = CheckNumber of int
| Cash
| Card of CardType * CardNumber

Another big topic and not enough time  
More on DDD and designing with types at
fsharpforfunandprofit.com/ddd

Slides and video here
F# consulting
fsharpforfunandprofit.com/csharp
F# for C# programmers

F# for C# Programmers

More Related Content

What's hot (20)

Similar to F# for C# Programmers (20)

More from Scott Wlaschin (19)

Recently uploaded (20)

F# for C# Programmers