F# Presentation

A language you can brag about

Functional programming   The new hotness Next “big” .NET language   CTP this summer

OCaml offspring  Created by MS Research  Mixed mode language   Functional  OO  Imperative (if you must) Statically typed 

Yay! Type inference  let x = 7 ...also, immutable  let s = quot;kurtquot; let pi = 3.142 So, really just “values” 

let l = ['a';'b';'c';] // char list or list<char> Singly linked list  Still immutable!  let digits = [0..9] // int list

IEnumerable<T>  let s = {1..10} Useful for computing  // seq[1;2;3;...] unbounded lists

let me = (quot;kurtquot;, 6.0) Typed groups of values  // string * float Can “hold” anything  let point3d = (0,0,0) Basically awesome  // int * int * int

let add x y = x + y Like any other value  // int -> int -> int More type inference  let eight = add 3 5 Returns last expression  // eight = 8

Look ma! Generics!  let group x y = (x,y) // 'a -> 'b -> 'a * 'b  Auto-generalization

let rec fib n = if n < 2 then n Explicitly recursive  else Tail recursion  (fib (n - 1)) + (fib (n - 2))

type name = string type number = int type date = System.DateTime type meeting = | Personal of name * date | Phone of number * date let review = Personal(quot;Jasminequot;,System.DateTime.Now) let call = Phone(8675309, System.DateTime.Now)

let what_to_do (m : meeting) = match m with | Personal(name,date) -> printfn quot;Meeting with %s at %Aquot; name date | Phone(phone, date) -> printfn quot;Call %A at %Aquot; phone date

Functions are basic units of a program  We can mix them up in interesting ways   Less OO design patterns! “Cheap” functions are good   Code is more expressive

let add3 = add 3 let add x y = x + y // int -> int // int -> int -> int

let even x = x % 2 = 0 // int -> bool let numbers = [1..20] let (|>) x f = f x // int list let evens = // 'a -> ('a -> 'b) -> 'b numbers |> List.filter even // int list

List.fold_left // ('b -> 'a -> 'b) -> List.map // 'b -> // ('a -> 'b) -> // 'a list -> // 'a list -> // 'b // 'b list [1..10] |> List.fold_left [1..10] |> List.map add3 (fun acc x -> acc + x) 0 // [4;5;6;..;13] // 55

2520 is the smallest number that can be  divided by each of the numbers from 1 to 10 without any remainder. What is the smallest number that is evenly  divisible by all of the numbers from 1 to 20? - Project Euler projecteuler.net

“Mutable” keyword   For real variables There are imperative loops   Try not to use it too much

F# can be OO   Classes  Interfaces  Inheritance Cross language work   “Hide” implementation

type OrderLine(n:string, q:int, p:float) = let mutable currName = n let mutable currQuantity = q let mutable currPrice = p new (name, price) = OrderLine(name, 1, price) member x.Name with get() = currName and set name = currName <- name member x.SubTotal with get() = (Float.of_int quantity) * price member x.OneMore() = currQuantity <- currQuantity + 1 currQuantity

Why functional programming?   Easy to build incrementally  Simplified testing  Concurrency! Imperative can be good too   At times, it’s wickedly fast  It’s what we know

F# Presentation

by mrkurt on Apr 09, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 2

Statistics

F# Presentation — Presentation Transcript