F# workshop

Prerequisites

https://www.linqpad.net/ or anything that can execute a REPL¹⁾

↘ alternatives

Try F# in browser: http://www.tryfsharp.org/Create
Use Visual Studio https://www.visualstudio.com/
Get a full distribution: http://fsharp.org/use/windows/ OR http://fsharp.org/use/linux/

Agenda

hello(x)
Type providers (strongly typed)
Matching
Options

hello(x)

let hello = printf "Hello World"
hello

F# (pronounced “F Sharp”) is

Open Source
Multi platform
Modern, rising popularity
Lazy evaluated
Reusable
Concise (See signal-to-noise ratio)
Strongly typed
Functional first
- Use functional to write easy to test and understand code
- Use imperative for performance and compatibility
- Use objective for organization and encapsulation
Compiled

Not suitable for real time (unpredictable performance)
Hard to optimize (Functional languages fundamentally don't model how your computer works)
Functional first (different thinking process, you will need to re-learn)

programming language for writing simple code to solve complex problems.

let hello x = printfn "Hello %s" x
hello "world"

Introducing pipeline operator:

let hello x = printfn "Hello %s" x
"World" |> hello

pipeline operator definition

How to define the operator?

let inline (|>) x f = f x

let square x = x * x
let subtract x y = x - y

let ``complicated stuff`` x =
    printfn "%d" (add 5 (square x))

let ``another complicated stuff`` x =
    x |> square |> subtract 5 |> printfn "%d"

let equation x =
	x 
	|> (fun y -> y * y ) 
	|> (fun y z -> y - z ) 5
	|> printfn "%d"

Note that F# uses indentation to indicate block structure. Find out more here.

Getting data

The following example loads data from webpage and stores it in CSV file.

Click to display ⇲

Click to hide ⇱

open System.Net
open System
open System.IO
 
let myURL = @"..."
 
let fetchUrl callback url =        
    let req    = WebRequest.Create(Uri(url)) 
    use resp   = req.GetResponse() 
    use stream = resp.GetResponseStream() 
    use reader = new IO.StreamReader(stream) 
    callback reader url
 
let myCallback (reader:IO.StreamReader) url = 
    let htmlSource = reader.ReadToEnd()
    htmlSource
 
let getWebpageHTML = fetchUrl myCallback myURL
 
type FirstOrLast = 
	| GetFirst
	| GetLast
 
let getDataFromHTML (rawHTML:String) = 
	let split (split_point:String) (firstOrLast:FirstOrLast) (text:String) = 
		let array = text.Split([|split_point|], 2, StringSplitOptions.RemoveEmptyEntries)
		match firstOrLast with
		| GetFirst -> array.First()
		| GetLast  -> array.Last()
	rawHTML
	|> split @"<table id=""t2"">" GetLast
	|> split @"</table>"          GetFirst
 
let removeAllTags text =
    Regex.Replace(text, "<.*?>", String.Empty);
 
let getCSVfromHTML rawHTML = 
	let mutable (text:String) = String.Empty
	text <- rawHTML
	text <- text.Replace(@"</th>", ";");
	text <- text.Replace(@"</td>", ";");
	text <- text.Replace(@"</tr>", Environment.NewLine);
	text <- text.Replace(',', '|');
	text <- text.Replace('.', ',');
	text <- removeAllTags text
	text
 
let CSVresult = getCSVfromHTML (getDataFromHTML getWebpageHTML)
CSVresult.Dump()

An F# type provider is a component that provides types, properties, and methods for use in your program.
The key to information-rich programming is to eliminate barriers to working with diverse information sources. One significant barrier to including a source of information into a program is the need to represent that information as types, properties, and methods for use in a programming language environment.
Writing these types manually is very time-consuming and difficult to maintain. A common alternative is to use a code generator which adds files to your project; however, the conventional types of code generation do not integrate well into exploratory modes of programming supported by F# because the generated code must be replaced each time a service reference is adjusted.

References

¹⁾

Read, Evaluate, Print Loop

Mental Workbench

Table of Contents