Reasonable Code With Fsharp

embrace the paradigm
REASONABLE CODE WITH F#

SECTION: OVERVIEW
Help the human

SYNTAX
int euler1(int max) {
var total = 0;
for(var n=1; n<max; n++) {
if(n % 3 == 0 || n % 5 == 0){
total += n;
}
}
return total;
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#

SYNTAX – VS LINQ
int euler1(int max) {
return Enumerable.Range(1, max - 1)
.Where(n => n % 3 == 0 || n % 5 == 0)
.Sum();
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#

TYPE INFERENCE
int x = 3;
long y = 4;
var z = x + y; // = 7
C# let x = 3
let y:int64 = 4L
x + y
F#
The type 'int64' does not
match the type 'int'

AUTOMATIC GENERALIZATION
val firstInGroup :
g:('a -> 'b) -> list:seq<'a> -> seq<'b * 'a> when 'b : equality
public IEnumerable<Tuple<U,T>> firstInGroup<T,U>
(Func<T,U> g, IEnumerable<T> list) {
return list.GroupBy(g)
.Select(grp => new Tuple<U, T>(grp.Key, grp.First()));
}
C#
let firstInGroup g list =
list
|> Seq.groupBy g
|> Seq.map (fun (key,items) -> key, Seq.head items)
F#

GENERALIZE THIS!
int add<T>(T x, T y) where T: op_addition {
return x + y;
}
C#
let add x y = x + y
add 3 4
add 4.2 5.1
F# let inline add x y = x + y
add 3 4
add 4.2 5.1
add "hello" "World"
F#

IMMUTABILITY
Eliminate unintended side effects
Sets you up for multi-core programming
Debugging is easier
Testability is higher
Intended side effects are necessary
Performance

IMMUTABILITY - EXAMPLE
Example from “Inside F#” blog
let actions = List.init 5 (fun i -> fun() -> i*2)
for act in actions do
printf "%d " (act())
F#
List<Func<int>> actions = new List<Func<int>>();
for (int i = 0; i < 5; ++i) {
actions.Add( () => i * 2 );
}
foreach (var act in actions) {
Console.WriteLine( act() );
}
C#
The mutable variable 'i' is used in an invalid way.
Mutable variables cannot be captured by closures.
Consider eliminating this use of mutation or using a
heap-allocated mutable reference cell via 'ref' and '!'.

OVERVIEW
1.Human readable
2.Reusability
3.Sensible defaults

FUNCTIONS AND FUNCTIONAL TYPES
Which problem would you rather focus on?
a) Where the code should live
b) What the code should do

COMPOSITION VS INHERITANCE
Is-a relationship that extends the base class
Very high coupling
Subclasses may not need all functionality from base class
Subclass has to be aware of the base class’s implementation
Ninject StructureMap
Castle WindsorUnity
Interface-dependent

FUNCTION COMPOSITION
Pipeline Operator: |>
Return value of first function becomes the last parameter of second function
Forward Composition Operator: >>
Create new functions that are sequences of existing functions
webUrl
|> downloadPage |> extractMetaInfo |> categorizeResource
F#
let categorizeUrl =
downloadPage >> extractMetaInfo >> categorizeResource
let categorizeEmail =
parseEmail >> extractDetail >> categorizeResource
categorizeUrl webUrl
categorizeEmail email
F#

FUNCTION COMPOSITION
Partial Application
Create new functions by supplying some of the arguments to an existing function
let MSBuild properties (outputPath:string) (targets:string) =
//Do some msbuild stuff
let MSBuildDebug = MSBuild ["Configuration","Debug"]
let MSBuildRelease = MSBuild ["Configuration","Release"]
F#
* From FAKE

PATTERN MATCHING
let data = ("Cleveland", 390000)
let city, population = data
F#
let x = 9
match x with
| num when num < 10 -> printfn "Less than ten"
| _ -> printfn "Greater than or equal to ten"
F#

DISCRIMINATED UNIONS
type Shape =
| Square of int
| Rectangle of float*float
| Circle of float
F#
let getArea shape =
match shape with
| Square side -> float(side * side)
| Rectangle(w,h) -> w * h
| Circle r -> System.Math.PI * r * r
F#
let sq = Square 7
let rect = Rectangle 2.2 3.3
let cir = Circle 3.4
F#

OPTION TYPE
type Option<‘T> =
| None
| Some of ‘T
F#

FUNCTIONS AND FUNCTIONAL TYPES
1.Think small, build big
2.Model
3.Flow

COMPILER CHECKED CORRECTNESS
Step 1: Create types
Step 2: Lean on the compiler

UNITS OF MEASURE
unitsOfMeasure.fsx(11,19): error FS0001: Type mismatch. Expecting a
int<mi> []
but given a
int<km> []
The unit of measure 'mi' does not match the unit of measure 'km'
[<Measure>]
type mi
[<Measure>]
type km
// define some values
let mike = [| 6<mi>; 9<mi>; 5<mi>; 18<mi> |]
let chris = [| 3<km>; 5<km>; 2<km>; 8<km> |]
let totalDistance = (Array.append mike chris) |> Array.sum
F#

UNITS OF MEASURE
enum DistanceUnit {
Miles,
Kilometers
}
class Run {
private float distance;
private DistanceUnit unit;
public Run(float distance, DistanceUnit unit){
this.distance = distance;
this.unit = unit;
}
}
C#

EXHAUSTIVE PATTERN MATCHING
//Model
module Person =
type T = Person of string
let create name =
if String.IsNullOrWhiteSpace(name) then None
else Some(Person name)
let value (Person p) = p
//DAL
let save person =
//put the person in the database…
Some 42
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| None -> printfn "An error occurred"
| Some id -> printfn "The id for %s is %d" (Person.value p) id
F#

EXHAUSTIVE PATTERN MATCHING
//DAL
type DatabaseResult<'a> =
| Success of 'a
| UniqueViolation
| GeneralException of Exception
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| Success(id) ->
printfn "The id for %s is %d" (Person.value p) id
| UniqueViolation ->
printfn "The name %s already exists" (Person.value p)
| GeneralException(ex) ->
printfn "%s" ex.Message
F#

DATABASE ACCESS, TOO?
Amount of code added to project

COMPILER CHECKED CORRECTNESS
1.Focus on the problem
2.Don’t forget stuff

SUMMARY
To Reason: To make sense of
Syntax & Idioms
Functional composition
Compiler-checked correctness

Reasonable Code With Fsharp

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Reasonable Code With Fsharp (20)

Recently uploaded (20)

Reasonable Code With Fsharp

Editor's Notes