Table of Contents

F# workshop

Prerequisites

↘ alternatives

↘ alternatives

Agenda

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

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

1)
Read, Evaluate, Print Loop