FP Day 2011 - Turning to the Functional Side (using C# & F#)

Turning to the Functional side
(Using C# and F#)

Phil Trelford Tomas Petricek
http://trelford.com/blog http://tomasp.net/blog
@ptrelford @tomaspetricek

About Us

» Tomas
• Author of F# book for C# programmers
• Worked with the F# team at Microsoft
• First blogged about F# in May 2006

» Phil
• Software Developer and Architect
• Worked on first F# applications at Microsoft
• Co-organizer of London F# User Group

» http://functional-programming.net

Tutorial

Goals
» Introduce Functional Concepts with F# and C#

Non-goals
» Provide in-depth understanding
» Mass conversion to functional programming cult
» Sell books

Thoughtworks Technology Radar July 2011

F#

» Strongly Typed
» Functional
» Object Orientated
» Open Source
» .Net language
» In Visual Studio

Functional Programing

» Pure Functions
» Higher Order Functions
» Pattern Matching

Higher Order Functions
F# Map/Reduce C# Map/Reduce
let map f xs = seq { public static
IEnumerable<R> Map<T, R>
for x in xs do (this IEnumerable<T> xs,
Func<T, R> f)
yield f x {
foreach (var x in xs)
} yield return f(x);
}

let reduce f init items = public static R
Reduce<T, R>
let mutable current = init (this IEnumerable<T> xs,
R init,
for item in items do Func<R, T, R> f)
{
current <- f current item var current = init;
foreach (var x in xs)
current current = f(current, x);
return current;
}

Pattern Matching
F# C#
match day with switch (day) {
| 0 -> "Sunday" case 0: return "Sunday";
case 1: return "Monday";
| 1 -> "Monday" case 2: return "Tuesday";
| 2 -> "Tuesday" case 3: return "Wednesday";
case 4: return "Thursday";
| 3 -> "Wednesday" case 5: return "Friday";
| 4 -> "Thursday" case 6: return "Saturday";
default:
| 5 -> "Friday" throw new
ArgumentException("day");
| 6 -> "Saturday"
}
| _ –>

invalidArg "Invalid day"

Light Syntax

F# C#
public class Person
type Person(name:string,age:int) = {
public Person(string name, int age)
/// Full name {
_name = name;
member person.Name = name _age = age;
}
/// Age in years
private readonly string _name;
member person.Age = age private readonly int _age;

/// <summary>
/// Full name
/// </summary>
public string Name
{
get { return _name; }
}

/// <summary>
/// Age in years
/// </summary>
public int Age
{
get { return _age; }
}
}

Functional data structures

» A way of thinking about problems
» Model data using composition of primitives

Tuple Combine two values of different types

Discriminated Represents one of several options
Union

List Zero or more values of the same type

Tuples: Containers for a few different things

Discriminated Unions: Exclusive alternatives

Representing event schedule

Object-oriented way Functional way
Schedule Schedule
Tag : ScheduleType
GetNextOccurrence() : DateTime

Once Never Repeatedly Once Never Repeatedly

» Easy to add new cases » Easy to add new functions
» Hard to add new functions » Hard to add new cases

» Good thing about F# and Scala – you can use both!

Cutting the caterpillar

Head Head

Head
Head

Head

End!

Functional Lists in C#

» List is either empty or nonempty

List

Nonempty Empty
(head, tail)

• In C#, a class hierarchy with two classes
• In F#, a discriminated union with two cases

Functional lists in C#

public class FunctionalList<T> {
// Creates a new list that is empty
public FunctionalList();
// Creates a non-empty list
public FunctionalList(T head, FunctionalList<T> tail);

// Is the list empty?
public bool IsEmpty { get; }

// Properties valid for a non-empty list
public T Head { get; }
public FunctionalList<T> Tail { get; }
}

Domain Modelling

» Retail Domain -> Testing

» http://tomasp.net/fpday.zip

Yahoo Stock Prices

» Data stored in a CSV file
Date,Open,High,Low,Close,Volume,Adj Close
2011-10-12,407.34,409.25,400.14,402.19,22206600,402.19
2011-10-11,392.57,403.18,391.50,400.29,21609800,400.29
2011-10-10,379.09,388.81,378.21,388.81,15769200,388.81

» Read and print all data
open System.IO

let dir = __SOURCE_DIRECTORY__ + "dataaapl.csv"
let lines = File.ReadAllLines(dir)
for line in lines do
printfn "%s" line

Parsing CSV data

» Get some data for testing
let line1 = lines |> Seq.head
let line2 = lines |> Seq.skip 1 |> Seq.head

» Using arrays in F#
let arr = str.Split([| ',' |])
arr.[0]

» Converting strings to numbers
float "12.34"
DateTime.Parse("1985-05-02")

TASK #1
Iterate over lines, parse CSV and print date & price

Sequence expressions

» Exploring data using imperative loops
for year, value in yearlyAverages do
if value < 25.0 then
printfn "%d (only %f)" year value

» Can be turned into a sequence expression…
let badYears =
seq { for year, value in yearlyAverages do
if value < 25.0 then
yield year, value }

• Result has a type seq<int * float> (IEnumerable)
• Brackets: [| … |] for arrays, [ … ] for lists, set [ … ] for sets

TASK #2
Turn the parsing into a sequence expression

Organizing Source Code

» Compiled Libraries
• Allow C# users call F# code
• Encapsulate (complete) functionality
» F# Script Files
• Great for explorative programming
• Script can load some other files

// File1.fsx // File2.fsx
module StockData #load "File1.fsx"
open StockData
let getData name =
name, 99.0 getData "MSFT"

TASK #3
Write function that parses specified CSV file

Processing Data in F#

» Writing data processing query in F#

Lambda function All types are inferred
StockData.MSFT
|> Seq.filter (fun stock -> stock.Close - stock.Open > 7.0)
|> Seq.map (fun stock -> stock.Date)
|> Seq.iter (printfn "%A")
Partial function application
Custom operators

» Seq module provides functions for IEnumerable
• But some operations make only sense for arrays/lists
» Sequence expressions provide query-like syntax

Useful functions

» Basic Functions
• Seq.filter – filter elements using predicate (aka Where)
• Seq.map – turn values into different (aka Select)
» Aggregating all elements of a sequence
• Seq.max, Seq.min, Seq.averag – the obvious
• Seq.fold – general aggregation
» Grouping elements of a sequence
• Seq.groupBy – group using key
• Seq.pairwise – adjacent pairs
• Seq.windowed – sliding window
» For more see: http://fssnip.net/categories/Sequences

TASK #4
Find number of days when closing price is
larger than opening price by more than $5.

TASK #5
Calculate standard
deviation of the data

FSharpChart library

» Easy to use charting library for F#
• Based on .NET 4.0 Chart Controls (WinForms/ASP.NET)
Light-weight syntax
for projections Line chart expects
value or key * value
[ for st in StockData.MSFT -> st.Date, st.Open ]
|> FSharpChart.Line

» Designed to fit nicely with F#
[ for st in StockData.MSFT -> st.Date, st.Open ]
|> FSharpChart.Line
|> FSharpChart.WithTitle
( Text = "Microsoft Stock Prices",
Font = new System.Drawing.Font("Calibri", 16.0f) )

TASK #6
Create chart that shows values with 5 day average.
This can be done using Seq.windowed

TASK #7
Create chart that shows prices together with standard
deviation (over 5 day window) range

Processing data live and in parallel
» Observable » Parallel Sequence
• Source generates data • Parallel implementation
(push-based model) • Process large amount
• Process data on-the-fly of in-memory data
• F# libs and .NET Rx • Available in F# PowerPack

In-memory, but
prices |> Seq.windowed 100 processed in parallel
|> PSeq.ordered
|> PSeq.map averageAndSdv
Processing live
pricesEvent |> Observable.windowed 100 data on the fly
|> Observable.map averageAndSdv

The Problem

» Problems with I/O bound computations
• Avoid blocking user interface
• Handle many requests concurrently

» What needs to be done differently?
• Avoid creating and blocking too many threads
• Reliability and scalability are essential
• React to events (from I/O or even GUI)

Using Explicit Callbacks

» Event-based programming model
HttpServer.Start("http://localhost:8080/", fun ctx ->
WebClient.DownloadAsync(getProxyUrl(ctx), fun data ->
ctx.ResponseStream.WriteAsync(data, fun res ->
ctx.ResponseStream.Close())))

• Callback called when operation completes
• Gaining popularity (e.g. Node.js)
» Does not solve all problems
• Control structures don’t work (loops, try-catch, …)
• Difficult to work with state

Synchronous to Asynchronous

» What would we want to write?
let copyPageTo url outputStream = async {
try
let html ==WebClient.AsyncDownload(url)
let! html WebClient.AsyncDownload(url)
outputStream.AsyncWrite(html)
do! outputStream.AsyncWrite(html)
finally
ctx.ResponseStream.Close() }

» Turning synchronous to asynchronous
• Wrap body in an async block
• Asynchronous calls using do! and let!
• Supports all F# control flow constructs

Async GUI programming

» Controlling semaphore light
• Using int or enum to keep current state?
• Difficult to read – what does state represent?
» Better approach – asynchronous waiting
• Loop switches between state
• Asynchronous waiting for events

green orange red

Writing loops using workflows

» Using standard language constructs

let semaphoreStates() = async {
Infinite loop!
while true do
for current in [ green; orange; red ] do
let! md = Async.AwaitEvent(this.MouseDown)
display(current) }
Wait for click
» Key idea – asynchronous waiting
• F# events are first class values
• Can use functional & imperative style

Checkout application workflow

» Think of a simple while loop
Startup

Scan items

Next customer Complete purchase

Print summary

Asynchronous and concurrent programming

» Asynchronous GUI in Checkout example
• Single-threaded thanks to Async.StartImmediate
• Easy way to encode control flow

» Parallel programming
• Workflows are non-blocking computations
• Run workflows in parallel with Async.Parallel

» Concurrent programming
• Compose application from (thousands of) agents
• Agents communicate using messages

Summary

» FP is already in the mainstream
» FP languages are ready
» Start small, go big
• Language Orientated Programming
• Exploratory and Scripting
• Asynchronous & Concurrency
• Technical Computing
• Testing

Meet the F#ers

@rickasaurus

@tomaspetricek

@dmohl

On the horizon

» http://functional-programming.net

http://meetup.com/fsharplondon
Every 6 weeks @ Skills Matter

Q&A

» http://Fsharp.net
» http://fssnip.net
» http://tomasp.net/blog
» http://trelford.com/blog

FP Day 2011 - Turning to the Functional Side (using C# & F#)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (8)

Similar to FP Day 2011 - Turning to the Functional Side (using C# & F#)

Similar to FP Day 2011 - Turning to the Functional Side (using C# & F#) (20)

More from Phillip Trelford

More from Phillip Trelford (20)

Recently uploaded

Recently uploaded (20)

FP Day 2011 - Turning to the Functional Side (using C# & F#)

Editor's Notes