Tokyo F# meetup 14-08-03

Functional thinking, a universal tool for the digital world
Nicolas Rolland
August 3, 2014
Nicolas Rolland Functional prototyping August 3, 2014 1 / 34

Table of Contents
1 Types
why types ?
Warm-up exercices
IEnumerable and IObservable
2 Universals, programming against the interface and existentials
universals
it sounds like ”L” in SOLID ..
existentials
3 Prototyping the functional way
Parser combinator

Table of Contents
1 Types
why types ?
Warm-up exercices
universals
existentials
Parser combinator

Types
What is a type ?

Types
What is a type ?
Type
A type is a set of values.

Types
What is a type ?
Type
why do we need to think of it in typed functional programming ?
a value is a value e.g. 1

Types
What is a type ?
Type
a function is a value too !
let plus = (+) //fun x y -> x + y
let plusone = plus 1 //fun x -> x + 1
let three = plusone 2 //3

Types
What is a type ?
Type
a function is a value too !
let plus = (+) //fun x y -> x + y
let plusone = plus 1 //fun x -> x + 1
let three = plusone 2 //3
hence everything is a value, everything has a type !

Using types

Using types
by restriction we get correctness - The computer tells us the errors

Using types
restriction tells readers a speciﬁcation - We can communicate to other
people

Using types
restriction tells readers a speciﬁcation - We can communicate to other
people
Types should be helping you, not get in your way.
No need to write the types in F#. Less work AND more security !
You can write the types for the purpose of communication with others

Warm-up exercices

what can I do with a value of this type ?
Type1
() −→ T

Type1
() −→ T
let a = (fun () -> 3) : unit -> int

Type1
() −→ T
lazy values !

Type1
() −→ T
lazy values !
let delayedValue = fun () -> someComputationForLater())
T ∼= () → T

Type1
() −→ T
lazy values !
let delayedValue = fun () -> someComputationForLater())
T ∼= () → T
let delay x = fun () → x : T → (() → T)
let force f = f () : (() → T) → T
delay force = Id()→T
force delay = IdT

Type2
type Type2 < T >= | Case1 of (T ∗ Type2 < T >)
| Case0

Type2
| Case0
let a = Case1(1,Case1(2,Case1(3,Case0)))

Type2
| Case0
let a = Case1(1,Case1(2,Case1(3,Case0)))
This is a list !
match l with
| Case1(value, rest) -> ... //do something with value
| Case0 -> ... //do something else

Type3
type RComp < T >= | NotYet of (() → RComp < T >)
| Finished of T

Type3
| Finished of T
let c = NotYet(fun () -> (*first part*)
NotYet (fun () -> (*second part*)
Finished pi))

Type3
| Finished of T
let c = NotYet(fun () -> (*first part*)
NotYet (fun () -> (*second part*)
Finished pi))
Resumable computation !

can you recognize IEnumerable ?
What is a value of type IEnumerable ?

What is a value of type IEnumerable ? a sequence of items

Item
type Item of T = | Finished | Value of T

Item
type Item of T = | Finished | Value of T
IEnumerable
type IEnumerable < T > = () → (() → Item of T)

Object Oriented way

Object Oriented way
public interface IEnumerator
{
bool MoveNext();
Object Current {
get;
}
void Reset();
}
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
How can I read the protocol ?
Should I call MoveNext first ?
What is the value of current
after enumeration is finished ?
How can I make sure current is
not used after enumeration is
finished ?

IObservable / Reactive
type IObservable < T > = (Item of T → ()) → ()

IEnumerable
Don’t they look similar .... ?

IEnumerable
Don’t they look similar .... ?
why ?

What is a type - take 2
What is a type and why do we need to think of it ?

Type
A type is a computable speciﬁcation

Type
A type is a computable speciﬁcation
Domain Driven Design : the architecture is the code

Together

Table of Contents
1 Types
why types ?
Warm-up exercices
universals
existentials
Parser combinator

Universals
Type
let empty () = System.Collections.Generic.List()
let stringList = empty()
do stringList.Add("hello")
let intList = empty()
do intList.Add(1)
type List<’T> = | Empty | Cons of (’T * List<’T>)
let stringList = Empty
let stringList = Cons ("hello", stringList)
let intList = Empty
let intList = Cons (1, intList)
What is the type of Empty

Universals
Type
do intList.Add(1)
let intList = Empty
What is the type of Empty ?
Empty : ∀T. List < T >
What is the type of Cons

Universals
Type
do intList.Add(1)
let intList = Empty
What is the type of Empty ?
Empty : ∀T. List < T >
What is the type of Cons ?
Cons : ∀T. T ∗ List < T >→ List < T >

Universals
What is the type of Empty ? Empty : ∀T. List < T >
”I don’t need to know anything about the type to do my job, I will
only refer to it opaquely as T”
implementer of List < T >
does not know T
user of List < T >
provide the type T

Liskov substitution ”principle” - Program to interface
type ICurrencyQuoteProvider =
abstract getQuote : string -> double
type BloombergCurrencyQuoteProvider(licenceToken:obj) =
interface ICurrencyQuoteProvider with
member this.getQuote cur = 120.0 //implementation logic
type TestQuoteProvider() =
interface ICurrencyQuoteProvider with
member this.getQuote cur = 120.0
//program to **interface**
type Basket(curProv:ICurrencyQuoteProvider) =
//add to basket etc...
member this.getTotalJPY () = 0.0 //implementation logic
member this.getTotalIn cur = this.getTotalJPY () * curProv.getQuote cur
let testBasket = Basket(TestQuoteProvider())
let prodBasket = Basket(BloombergCurrencyQuoteProvider(...))

Existentials
Interfaces allows to abstract in object oriented programming
Like universals types, it ”hides” something, but what is the relation ?

Existentials
Functional is Mathematics ! Abstraction in FP has to have a precise
deﬁnition related to universals !

Existentials
Functional is Mathematics ! Abstraction in FP has to have a precise
deﬁnition related to universals !
Universals deﬁnition
empty : ∀T. () → List < T >
suggests ”existentials”
absStack : ∃T{empty : () → T
push : int ∗ T → T
pop : T → T
top : T → int}
” I’ll use whatever type I want here; you wont know anything about
the type, so you can only refer to it opaquely as X”

absStack : ∃T{empty : () → T
push : int ∗ T → T
pop : T → T
top : T → int}
implementer
Know about the speciﬁc type T
user
does not know about the speciﬁc
type T, only about the interface

duality

duality
IEnumerable vs IObservable
Universals vs Existentials
are examples of applying duality

Erik Meijer - he will reverse all your arrows

Functional programming and duality is old : we know it
works

encoding in Fsharp
// ∀ t . Stack(t)
type StackOps<’Rep> = {
empty :’Rep
isEmpty :’Rep -> bool
push : (int *’Rep) -> ’Rep
pop :’Rep -> ’Rep
top :’Rep -> int
}
// ∃ t. Stack(t)
[<AbstractClass>]
type ExistentialStack()=
// ∀ x. (∀ t . Stack(t) − > x) − > x ∼= ∃ t. Stack(t)
abstract Apply : StackClient<’x> -> ’x
and Stack<’Rep>(e:’Rep,ops:StackOps<’Rep>)=
inherit ExistentialStack()
member this.witness = e
member this.getOps = ops
override this.Apply(mc) = mc.Apply<’Rep>(this)
and StackClient<’y> = interface
// ∀ t. Stack(t) − > y
abstract member Apply<’t> : Stack<’t> -> ’y

stack demo

Existentials - References
Luca Cardelli, Peter Wegner (1985)
On Understanding Types, Data Abstraction, and Polymorphism
William Cook (2009)
On Understanding Data Abstraction, Revisited

Table of Contents
1 Types
why types ?
Warm-up exercices
universals
existentials
Parser combinator

How do we go from here to there ?
string
”[a number is like 1234 but
can also be 9.12 ]”
value
let b = List([String "a"
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])

string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])
This is a job for .....

string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])
This is a job for ..... grep ?

string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])
This is a job for ..... grep ? imperative ?

string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])
This is a job for ..... grep ? imperative ? or...

string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])
This is a job for ..... grep ? imperative ? or... λ !

lambda man !

start with the types

start with the types
value type
type Val = | List of Val list
| NumberI of int
| NumberF of double
| String of string
value
String "number"
String "is"
String "like"
NumberI 1234
List ([
String "but"
String "can"
String "also"
String "be"
NumberF 9.12
]) ])

parser return type - ﬁrst try
type ParseReturn<’ret> = | Success of ’ret | Failure of string
type Parser<’ret,’token> =
List<’token> -> ParseReturn<’ret> * List<’token>

reading the parser type
a parser takes a list of token in
it returns a ParserReturn , and the tokens not yet processed

a parser takes a list of token in
it returns a ParserReturn , and the tokens not yet processed
a ParserReturn is the value represented by the token consumed
Ok, but........ ”9.12 ” :
9 is a number.. but if we recognize ”9” as 9 only, what do we do for
”.12” ?
=⇒ the result of a parser depends also on the rest of the string
If it matters, it should be part of the returned type of a parser !

parser return type
type ParseReturn<’ret,’token> =
| Success of ’ret *(’token list)
| Failure of string
’token list -> ParseReturn<’ret,’token>
e.g. ”9.12 ”
Each success contains a recognized value along with the
”rest”
Because the notion of what is the ”rest” is dependent on the
Val produced
ParseReturn now contains a coherent and actionable unit of
information

demo time

There are many more tricks to practice

The End

Tokyo F# meetup 14-08-03

Recommandé

Recommandé

Contenu connexe

Similaire à Tokyo F# meetup 14-08-03

Similaire à Tokyo F# meetup 14-08-03 (20)

Dernier

Dernier (20)

Tokyo F# meetup 14-08-03