Upcoming SlideShare
×

# F# Rocks

650

Published on

Published in: Technology
0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total Views
650
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
6
0
Likes
0
Embeds 0
No embeds

No notes for slide

### F# Rocks

1. 1. F♯ It Rocks. But Why?
2. 2. Why Does it Rock? • It makes it easy to write code which communicates its purpose clearly. • Static guarantees without the screen fuzz. • Fewer surprises == fewer bugs. • Just ‘cos.
3. 3. Big Picture • Succinct “Succinctness is Power” - Paul Graham, 2002 • Declarative • Leverages .net framework libraries • Interoperates with .net libraries/ applications
4. 4. Incomprehensible Bunch o’ Code
5. 5. printfn  "Hello,  world!" let  rec  fib  = function |  0  |  1  as  n  -­‐>  n |  n                    -­‐>  fib  (n  -­‐  1)  +                                fib  (n  -­‐  2) The Obvious Stuff
6. 6. Project Euler Prob. 1 [  for  i  in  1..999  do          if  i  %  3  =  0  ||  i  %  5  =  0        then  yield  i  ] |>  List.sum |>  printfn  "%i" Find the sum of all the multiples of 3 or 5 below 1000.
7. 7. let  sq                n  =  n  *  n let  sumUpTo      n  =  n  *  (n  +  1)  /  2 let  sumSqUpTo  n  =  [1..n]                                      |>  List.fold  (fun  s  x  -­‐>  s  +  sq  x)  0 let  sqSumUpTo  =  sumUpTo  >>  sq sqSumUpTo  100  -­‐  sumSqUpTo  100 |>  abs |>  printfn  "%i" Project Euler Prob. 6 Find the difference between the sum of the squares of the ﬁrst one hundred natural numbers and the square of the sum.
8. 8. Juicier Example - Simple Parser
9. 9. Core Types type  Expr<'a>  = |  Value        of  'a |  Add            of  Expr<'a>  *  Expr<'a> |  Subtract  of  Expr<'a>  *  Expr<'a> type  Token  = |  Value  of  string |  Add  |  Subtract
10. 10. Lexer I let  (|Empty|_|)  (s:  seq<_>)  =      if  Seq.isEmpty  s  then  Some  ()  else  None let  (|Regex|_|)  regex  str  =      Regex.Matches(str,  regex)    |>  Seq.cast<Match>    |>  function          |  Empty  -­‐>  None          |  ms        -­‐>  ms                                  |>  Seq.map  (fun  m  -­‐>  m.Value)                                |>  List.ofSeq                                |>  Some
11. 11. Lexer II let  lex  (str:  string)  =    let  assign  =        function        |  "+"  -­‐>  Token.Add                      |  "-­‐"  -­‐>  Token.Subtract        |  v      -­‐>  Token.Value  v    let  pattern  =  "[+-­‐]|([^+-­‐s]+)"    str    |>  function          |  Regex  pattern  ms  -­‐>  ms  |>  List.map  assign          |  _                                -­‐>  []
12. 12. Parser let  parse  (conv:  string  -­‐>  'a)  (tokens:  Token  List)  =    let  get  =  conv  >>  Expr.Value    let  (|Val|)  =          function        |  Token.Value  str  -­‐>  str  |>  get        |  _                              -­‐>  failwith  "Parse  Error."    let  add  l  r  =  Expr.Add            (l,  r)    let  sub  l  r  =  Expr.Subtract  (l,  r)    let  rec  expr  =        function        |  (Val  v)  ::  Token.Add            ::  tl  -­‐>  add  (expr  tl)  v        |  (Val  v)  ::  Token.Subtract  ::  tl  -­‐>  sub  (expr  tl)  v        |  (Val  v)  ::  []                                      -­‐>  v        |  _                                                              -­‐>  failwith  "Parse  Error."    tokens  |>  List.rev  |>  expr
13. 13. Evaluator let  rec  eval  (exp:  Expr<_>)  =    let  assoc  =        GlobalAssociations.GetNumericAssociation  ()    match  exp  with    |  Expr.Value        v            -­‐>  v    |  Expr.Add            (l,  r)  -­‐>  assoc.Add            (eval  l,  eval  r)    |  Expr.Subtract  (l,  r)  -­‐>  assoc.Subtract  (eval  l,  eval  r)
14. 14. assert  ("10  +  3  -­‐  5  -­‐  6  +  2"                  |>  lex                  |>  parse  Int32.Parse                  |>  eval                  =  4) assert  ("10.5  +  3.7  -­‐  5.2  -­‐  6.7  +  2.5"                  |>  lex                  |>  parse  Double.Parse                |>  eval                    =  4.8) Tests
15. 15. End Of Incomprehensible Bunch o’ Code
16. 16. So What? • The tour should give an indication of the ingredients of F#’s awesomeness • You often end up write the code right ﬁrst time • Flexible so you can go mutable/ interoperate with .net as needed
17. 17. Mea Culpa • 5 minutes isn’t long enough to do it justice • I’ve missed out many, many, many brill things • I’m just ‘some guy’ who likes F♯ - so excuse my mistakes/obvious lack of skillz • Go and play with it! It rocks! Honest!
1. #### A particular slide catching your eye?

Clipping is a handy way to collect important slides you want to go back to later.