Functional programming in F#

About functional programming in general and F# in particular

Transcript

1. Functional programming in F# The Why, What and How
2. Back in the days... λ LISP ISWIM APL FP ML 1958 1966 1962 1977 1973 Haskell 1988 Scala 2003 Ocaml 1996 F# 2005 Clojure 2007 1930-ish Erlang 1986
3. Some definitions Program Data - Logic - Control Declarative Logic - Referential transparency Imperative Logic - Control - Side effects
4. Functional programming language First class Higher-Order Functions Immutability Declarative λ
5. The PAIN of imperativeness Screwupability Shared mutable states
6. Why not functional programming? • Too low dev replacability • Legacy code not functional • Bad interop, few libs • Devs find it too hard • Customers don’t care anyway
7. Why Functional Programming? let sum lst = foldr (+) lst 0 let product lst = foldr (*) lst 1 let append l1 l2 = foldr cons l1 l2 let length lst = foldr (+) lst 0 let map f lst = foldr (cons << f) lst []
8. FP demand UK Scala Clojure F# Erlang
9. Real-world uses F# Svea Ekonomi, Microsoft (Halo), Credit Suisse, Prover Haskell AT & T, Scrive Erlang Ericsson, Klarna, Basho, Facebook Lisp Yahoo Store Scala Twitter, LinkedIn
10. Why F#? Functional + OO + .NET + Open Source => The Most Powerful Language In The WORLD! Scala-crowd goes: O rly? Lisp-crowd goes: F-what?
11. F# “F# is a practical, functional-first language that lets you write simple code to solve complex problems"
12. Complex Simple static Tree<KeyValuePair<A, bool>> DiffTree<A>(Tree<A> tree, Tree<A> tree2) { return XFoldTree( (A x, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> l, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> r, Tree<A> t) => (Tree<A> t2) => Node(new KeyValuePair<A, bool>(t2.Data, ReferenceEquals(t, t2)), l(t2.Left), r(t2.Right)), x1 => y => null, tree)(tree2); }
13. Tree<KeyValuePair<A, bool>> DiffTree<A>(Tree<A> tree, Tree<A> tree2) { XFoldTree( (A x, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> l, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> r, Tree<A> t) => (Tree<A> t2) => Node(new KeyValuePair<A, bool>(t2.Data, ReferenceEquals(t, t2)), l(t2.Left), r(t2.Right)), x1 => y => null, tree)(tree2); } Complex Simple
14. DiffTree ( tree, tree2) { XFoldTree( ( x, l, r, t) => (Tree<A> t2) => Node(new KeyValuePair<A, bool>(t2.Data, ReferenceEquals(t, t2)), l(t2.Left), r(t2.Right)), x1 => y => null, tree)(tree2); } Complex Simple
15. DiffTree ( tree, tree2) { XFoldTree( ( x, l, r, t, t2) => Node(new KeyValuePair<A, bool>(t2.Data, ReferenceEquals(t, t2)), l(t2.Left), r(t2.Right)), x1 => y => null, tree)(tree2); } Complex Simple
16. DiffTree ( tree, tree2) { XFoldTree( ( x, l, r, t, t2) => let (Node(x2,l2,r2)) = t2 Node((x2,t=t2), l l2, r r2)) (fun _ _ -> Leaf) tree tree2; } Complex Simple
17. DiffTree ( tree, tree2) XFoldTree( x, l, r, t, t2 => let (Node(x2,l2,r2)) = t2 Node((x2,t=t2), l l2, r r2)) (fun _ _ -> Leaf) tree tree2 Complex Simple
18. let DiffTree ( tree, tree2) = XFoldTree(fun x, l, r, t, t2 -> let (Node(x2,l2,r2)) = t2 Node((x2,t=t2), l l2, r r2)) (fun _ _ -> Leaf) tree tree2 Complex Simple
19. let DiffTree( tree, tree2) = XFoldTree(fun x, l, r, t, t2 -> let (Node(x2,l2,r2)) = t2 Node((x2,t=t2), l l2, r r2)) (fun _ _ -> Leaf) tree tree2 Complex Simple
20. (Function) values in F# let ten = 10 let square x = x*x let squareList = List.map (fun n -> n*n) let addThree = (+) 3
21. (Function) values in F# let outer x = let inner y = printfn "outer + inner = %d" (x + y) inner 21 let rec sum list = match list with | [] -> 0 | head::tail -> head + sum tail
22. let rec merge l1 l2 = match l1, l2 with | [], xs | xs, [] -> xs | x::xs', (y::_ as ys) when x <= y -> x::merge xs' ys | xs, y::ys' -> y::merge xs ys' Pattern matching Named pattern Guarded pattern Parallel pattern OR pattern
23. F# data types + * Algebraic Data Types
24. F# data types - Union type Shape = | Circle of float | Rectangle of float * float | Triangle of float * float
25. F# data types – Recursive union type BinTree = | Leaf of int | Node of BinTree * BinTree
26. F# data types - Option type Option<'a> = | Some of 'a | None
27. F# data types - Option public Document getDocByID(int id); VS val getDocByID : int -> Document option
28. F# data types - Option let res = match getDocByID id with | None -> …handle not found… | Some(d) -> …do something with d…
29. F# data types - List type List<'a> = | Nil | Cons of 'a*List<'a> Nil + 'a*List<'a>
30. F# data types - List let l1 = ["a"; "list"; "of"; "strings"] let l2 = "a"::"consed"::"list"::[] let l3 = [1..42] let l4 = [for i in l3 -> i*i]
31. Higher-order functions let rec double l = match l with | [] -> List.empty | h::t -> h*2::double t
32. Higher-order functions let rec length (l:string list) = match l with | [] -> List.empty | h::t -> h.Length::length t
33. Higher-order functions let rec map f l = match l with | [] -> List.empty | h::t -> f(h)::map t
34. Higher-order functions map (fun x -> 2*x) list map (fun (x:string) -> x.Length) list
35. Pipelining h(g(f(x))) VS x |> f |> g |> h Pipeline operator
36. Function composition let f x = h(g(x)) VS let f = g >> h Composition operator
37. Function composition let double_then_sum = List.map ((*)2) >> List.reduce (+)
38. Synchronous -> Asynchronous let getData (url:string) = let r = WebRequest.Create(url) let resp = r.GetResponse() use stream = resp.GetResponseStream() use reader = new StreamReader(stream) let data = reader.ReadToEnd() data
39. F# 3.0 • Type Providers • Query Expressions • Triple-quoted strings
40. Summary Functional programming lets you Focus on the problem and less on noise Write consice and readable code Create composable programs F# gives you Access to the .NET framework Cross-platform Multiparadigm for solving real-world problems
41. So... λ = Future? Complex vs Simple Lots of plumbing vs Logic Spaghetti vs Composability Headache vs Fun
43. Jayway christian.jacobsen@jayway.com @chribben Functional Programming Sthlm User Group Jayway seminars Øredev