1. Functional
Programming
{ F# Programming Techniques

2.  Oleksiy Tereshchenko
 Principal consultant at Neudesic
 10 years experience in Custom Application
Development and Connected Systems
About Presenter

3.  Building Blocks
 Tuples
 Discriminated Unions
 Lists
 Stack (as example of OOD)
 Recursive Functions
 Assembling Parser
 Demo
& Questions
Agenda

4.  Tuples
 Discriminated Unions
 Lists
 Stack
 Recursive Functions
Building Blocks

5. let makeAndYear = ("Ford", 2011)
type CarMakeAndYear = string * int
let (make,year) : CarMakeAndYear = makeAndYear
Debug.WriteLine(make)
Debug.WriteLine(year)
match makeAndYear with
| ("Honda", 2010) -> Debug.WriteLine("Matched Honda 2010")
| ("Honda", year) -> Debug.WriteLine("Matched Honda " +
year.ToString())
| ( _ , _ ) -> Debug.WriteLine("This is not Honda")
Tuples

6. type Operation = Plus | Minus | Multiply | Devision
type Value = IntValue of int
type ParseTree = Leaf of Value | Node of ParseTree * Operation * ParseTree
let plusOperation = Plus
let treeLeafLeft = Leaf(IntValue(100))
let treeLeafRight = Leaf(IntValue(100))
let treeNode = Node(treeLeafLeft, Plus, treeLeafRight)
let parentTree = Node(treeNode, Multiply, Leaf(IntValue(2)))
Discriminated Unions

7. let listOfNumbersA = [1;2;3]
let listOfNumbersB = [1..10]
let listOfNumbersAB = listOfNumbersA @ listOfNumbersB
let listOfNumbersC = 50 :: listOfNumbersA
match listOfNumbersA with
|intValue :: listOfNumbersD -> Debug.WriteLine(intValue)
|_-> ()
let head = listOfNumbersB.Head
Lists

8. type StackNode<'a> = Nil | StackNode of 'a * StackNode<'a>
type Stack<'a>() =
let mutable stackNode : StackNode<'a> = Nil
member self.Node : StackNode<'a> = stackNode
member self.Push( leaf : 'a ) =
stackNode <- StackNode(leaf, self.Node)
member self.Pop() : 'a option =
match stackNode with
| Nil ->
None
| StackNode(leaf,tailNode) ->
stackNode <- tailNode; Some(leaf);
Stack

9. let rec SumArithmeticProgression( x) =
if x < 1 then
x
else
x + SumArithmeticProgression ( (x-1))
let rec SumArithmeticProgressionTailRecursion ( x, acc) =
if x < 1 then
acc
else
SumArithmeticProgressionTailRecursion ( (x-1), (acc + x))
Recursive Functions

10. let PrintToken (token : Token) =
match token with
| Operation(operation) -> PrintOperation(operation)
| Bracket(LeftBracket) -> Debug.Write "("
| Bracket(RightBracket) -> Debug.Write ")"
| Letter(Value(value)) -> PrintValue value
| Letter(ParseTree(parseTree)) -> PrintTree parseTree
;;
let rec PrintSentence (sentence : Token List) =
match sentence with
| token :: tail -> PrintToken(token); PrintSentence(tail);
| [] -> ()
;;
Recursive Functions

11. 5 * (3 + 4) = 35
Assembling Parser
(Calculator Parser)

12. Tokenize
Expression
Parse Sentence
Print Tree
Compute
Expression
Print Result
Assembling Parser
(Flow Chart)

13. L =V
L =T
L ao L = L ao L mo L
L =LoL
L =(L)
L – Letter
V – Value
T – Tree
o – Operation
ao – Additive Operation
mo – Multiplicative Operation
Assembling Parser
(Production Rules)