F♯
It Rocks. But Why?
Why Does it Rock?
• It makes it easy to write code which
communicates its purpose clearly.
• Static guarantees without the...
Big Picture
• Succinct
“Succinctness is Power” - Paul Graham, 2002
• Declarative
• Leverages .net framework libraries
• In...
Incomprehensible
Bunch o’ Code
printfn	
  "Hello,	
  world!"
let	
  rec	
  fib	
  =
function
|	
  0	
  |	
  1	
  as	
  n	
  -­‐>	
  n
|	
  n	
  	
  	
  	...
Project Euler Prob. 1
[	
  for	
  i	
  in	
  1..999	
  do	
  
	
  	
  	
  	
  if	
  i	
  %	
  3	
  =	
  0	
  ||	
  i	
  %	...
let	
  sq	
  	
  	
  	
  	
  	
  	
  	
  n	
  =	
  n	
  *	
  n
let	
  sumUpTo	
  	
  	
  n	
  =	
  n	
  *	
  (n	
  +	
  1)...
Juicier Example -
Simple Parser
Core Types
type	
  Expr<'a>	
  =
|	
  Value	
  	
  	
  	
  of	
  'a
|	
  Add	
  	
  	
  	
  	
  	
  of	
  Expr<'a>	
  *	
 ...
Lexer I
let	
  (|Empty|_|)	
  (s:	
  seq<_>)	
  =	
  
	
  	
  if	
  Seq.isEmpty	
  s	
  then	
  Some	
  ()	
  else	
  None...
Lexer II
let	
  lex	
  (str:	
  string)	
  =
	
  	
  let	
  assign	
  =
	
  	
  	
  	
  function
	
  	
  	
  	
  |	
  "+"	...
Parser
let	
  parse	
  (conv:	
  string	
  -­‐>	
  'a)	
  (tokens:	
  Token	
  List)	
  =
	
  	
  let	
  get	
  =	
  conv	...
Evaluator
let	
  rec	
  eval	
  (exp:	
  Expr<_>)	
  =
	
  	
  let	
  assoc	
  =
	
  	
  	
  	
  GlobalAssociations.GetNum...
assert	
  ("10	
  +	
  3	
  -­‐	
  5	
  -­‐	
  6	
  +	
  2"	
  
	
  	
  	
  	
  	
  	
  	
  	
  |>	
  lex	
  
	
  	
  	
  ...
End Of
Incomprehensible
Bunch o’ Code
So What?
• The tour should give an indication of the
ingredients of F#’s awesomeness
• You often end up write the code rig...
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 ...
Upcoming SlideShare
Loading in...5
×

F# Rocks

650

Published on

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
650
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
6
Comments
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 first 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 first 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.

×