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

Complex Simple
DiffTree ( tree,
tree2)
{
XFoldTree(
( x, l,
r,
t)
=> (Tree<A> t2) =>
}

Complex Simple
DiffTree ( tree,
tree2)
{
XFoldTree(
( x, l,
r,
t, t2)
=>
}

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
=>
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
->

Complex Simple
let DiffTree(tree, tree2) =
XFoldTree(fun x, l, r, t, t2 ->

(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


public Document getDocByID(int id);

VS

val getDocByID : int -> Document 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


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


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


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

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Functional programming in f sharp

Semelhante a Functional programming in f sharp (20)

Último

Último (20)

Functional programming in f sharp

Notas do Editor