Functional programming in f sharp

Functional programming in F# The Why, What and How

Back in the days... ISWIM λ 1958 LISP 1966 1930-ish 1962 APL 1973 ML 2007 1977 FP Clojure 2005 F# 1986 Erlang 2003 Scala 1988 Haskell Ocaml 1996

Some definitions Program Data - Logic - Control Declarative Logic - Referential transparency Imperative Logic - Control - Side effects

Functional programming language Declarative First class λ Higher-Order Immutability Functions

The PAIN of imperativeness Screwupability Shared mutable states

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

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 []

FP demand UK Clojure Scala F# Erlang

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

Why F#? Functional + OO + .NET + Open Source => The Most Powerful Language In The WORLD! Scala-crowd goes: O rly? Lisp-crowd goes: F-what?

F# “F# is a practical, functional-first language that lets you write simple code to solve complex problems"

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); }

Complex Simple 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 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 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 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 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 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 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

(Function) values in F# let ten = 10 let square x = x*x let squareList = List.map (fun n -> n*n) let addThree = (+) 3

(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

Pattern matching let rec merge l1 l2 = Parallel pattern match l1, l2 with OR pattern | [], xs | xs, [] -> xs | x::xs', (y::_ as ys) when x <= y -> x::merge xs' ys | xs, y::ys' -> y::merge xs ys' Named pattern Guarded pattern

F# data types Algebraic Data Types + *

F# data types - Union type Shape = | Circle of float | Rectangle of float * float | Triangle of float * float

F# data types – Recursive union type BinTree = | Leaf of int | Node of BinTree * BinTree

F# data types - Option type Option<'a> = | Some of 'a | None

F# data types - Option public Document getDocByID(int id); VS val getDocByID : int -> Document option

F# data types - Option let res = match getDocByID id with | None -> …handle not found… | Some(d) -> …do something with d…

F# data types - List type List<'a> = | Nil | Cons of 'a*List<'a> Nil + 'a*List<'a>

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]

Higher-order functions let rec double l = match l with | [] -> List.empty | h::t -> h*2::double t

Higher-order functions let rec length (l:string list) = match l with | [] -> List.empty | h::t -> h.Length::length t

Higher-order functions let rec map f l = match l with | [] -> List.empty | h::t -> f(h)::map t

Higher-order functions map (fun x -> 2*x) list map (fun (x:string) -> x.Length) list

Pipelining h(g(f(x))) VS x |> f |> g |> h Pipeline operator

Function composition let f x = h(g(x)) VS let f = g >> h Composition operator

Function composition let double_then_sum = List.map ((*)2) >> List.reduce (+)

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

F# 3.0 • Type Providers • Query Expressions • Triple-quoted strings

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

So... Complex vs Simple Spaghetti vs Composability λ = Future? Headache vs Fun Lots of plumbing vs Logic

Jayway christian.jacobsen@jayway.com @chribben Functional Programming Sthlm User Group Jayway seminars Øredev

Functional programming in f sharp

More Related Content

What's hot

Similar to Functional programming in f sharp

Recently uploaded

Functional programming in f sharp

Editor's Notes