Dmitri Nesteruk

dmitrinesteruk @ gmail.com
http://spbalt.net
“…a programming paradigm that
treats computation as the evaluation
of mathematical functions and
avoids state and mutable data”
—Wikipedia
   Higher-order functions
  i => j => f(j)
  Pure functions
  Immutability
  No side effects
  (Tail) recursion
  let f(x) = …; f(x-1);
  Pattern matching
   Math
  Probabilistic models
  Symbolic processing (parsing/lexing)
  Symbolic differentiation
  Circuit verification
   Multi-paradigm language in .NET stack
  Functional
  Imperative
  Performance similar to C#
  Interactive console
  Support in Visual Studio
  Debugger
  Editor
  Mono support
   #light 
printfn “Hello, F#!” 

  #light 
Light syntax – cuts down on ceremony when
writing code
  Indentation instead of begin/end
  Use of in,done keywords not required
  No semicolons
  Currently mandatory – will be default in future
   printfn “Hello, F#”
Writes a line to the console
  A top-level binding (like a global function)
  Part of FSharp.Core
  Referenced implicitly
  Appears in a generated _main() 
  Can “Go To Definition”
   Can do it with a function

let sayHello = 
  printfn “Hello, F#!” 
sayHello 

  Or pass a parameter

let sayHello s = 
  printfn s 
sayHello "Hello, F#!" 
   Application operator |> (forward pipe)

let sayHello s = 
  s |> printfn // same as printfn s 

  Explicit types

let length a = a.Length; // not ok 
let length (a:string) = 
  a.Length // ok
   Recursive definition

let rec factorial n = 
  if n <= 1 then 1  
  else n * factorial(n‐1) 

  Mutual recursion 

let rec funcA x = 1 + funcB(x) 
and funcB x = 1 – funcA(x) 
   One statement per line, use in for more
  let powerOf4 x = 
  let y = x * x in y * y 
  No implicit conversions
  let GetXName xname = 
  XName.op_Implicit(xname) 
  Aggressive strong typing
  let o:obj = “test”; // fails 
  let o = box “test”; // ok 
  Mutability must be explicit
  mutable keyword
  variable <‐ value to assign
   Clever switch statement
  Can match values of any type

  let matchMe x = 
  match x with 
  | 1 ‐> printfn "one"  
  | 2 ‐> printfn "two"  
  | _ ‐> printfn "something else"

  Cannot bind same pattern element twice

  Cannot match (x, x)
  Can match (x, y) when x = y
   Tuple
  Option value
  Array
  Sequence
  List
   Contains several values of any types
  No more Pair<T,U> etc. classes

  let sumAndProduct a b = 
  (a+b, a*b)

  let (s, p) = sumAndProduct 2 3 
printfn "%d %d" s p 

  Tuples use comma ,

Other structures use semicolon ;
   null is typically not used with F# types
  Presence or absence can be discriminated with
an option value, which is
  None 
  Some of 'a 
  Use pattern matching 

match x with 
| Some(name) ‐> printfn name 
| None ‐> printfn “anonymous” 
   Your typical CLR array

let people = [|  
  “john”;  
  “jane”;  
  “jack”  
|] 

  people.Length 
  yields 3
   Enumerable values
  let a = seq [1; 2; 3] 
  let b = seq { for i in 1 .. 10 ‐> (i*i) } 
  Lazy-inited
  seq { 1 .. 10000000 } 
  Step
  seq { 1 .. 2 .. 10 } 
  yields 1, 3, 5, 7, 9
  Strings are char sequences
  printfn "%d" (Seq.length "Hello") 
  Iterated with for .. in .. do
  for i in mySeq do printfn “%d” i 
   Linked list of values

[1; 2; 3]

  Has head and tail

  Head is the first element 
  Tail is everything else 
  [] is the empty list
  [1, 2, 3] has length of 1:)
   let a = [1; 2; 3] 
  Head = 1 
  Tail = [2; 3] 
  let b = 0 :: a 
  [0; 1; 2; 3] 
  let c = a @ b 
  [1; 2; 3; 0; 1; 2; 3] 
   let rec sumAll myList = 
  match myList with 
  | h :: t ‐> head + sumAll(t) 
  | [] ‐> 0

  let rec nonZero myList = 
  match myList with 
  | 0 :: t ‐> 1 :: nonZero t 
  | h :: t ‐> h :: nonZero t 
  | [] ‐> [] 

  let rec htmlDecode text = 
  match text with 
  | ‘&’ :: ‘g’ :: ‘t’ :: ‘;’ :: tail ‐> 
      ‘>’ :: htmlDecode tail // and so on   
   A non-exhaustive match will throw a
MatchFailureException 

  Patterns can be grouped

  match person with 
| a :: (b :: c as subGroup) ‐> 
  match subGroup with 
   Anonymous functions
  Functional composition
  Partial application
  Memoization
   A way of defining nameless functions
  fun x ‐> x * 2 
  Can be passed as parameter
  Can be bound, i.e.
  let square = fun x ‐> x * x 
   Used to provide LINQ-like features to lists and sequences
  let myList = [1; 2; 3]
  List.iter (fun f ‐> printfn “%d” f) myList 
  Iterates through the collection
  List.map (fun f ‐> f + 1) myList 
  Returns a modified list [2; 3; 4] – LINQ Select()
  List.filter (fun f ‐> f % 2 = 0) myList 
  Returns only odd elements – LINQ Where()
  Other useful functions (e.g., List.to_array)
  Similar features in seq 
   Operators can be piped
  values |> List.map (fun f ‐> f + 1) 
       |> List.filter(fun f ‐> f > 0) 

  And functionally composed

  let even = List.filter  
                (fun f ‐> f % 2 = 0) 
let positive = List.filter 
                (fun f ‐> f > 0) 
let evenAndPos = even >> positive 
  evenAndPos [1; ‐2; 4] 
  yields [4]
   let squareThis x = 
  x * x  
  let addFive x = 
  x + 5 
  5 |> squareThis |> addFive 
  yields 30
  let squareAndAddFive = 
  squareThis >> addFive 
  squareThisAndAddFive 5 
  yields 30
   let shift (dx, dy) (px, py) =  
  (px + dx, py + dy) 

  shift (1, 0) (100, 100) 
  result is (101, 100)

  let shiftRight = shift (1, 0)

  shiftRight (100, 100) 
  result is (101, 100)
   Keep a lookaside table of computed values

  let rec fib n = 
  if n <= 2 then 1 
  else fib(n‐1) + fib(n‐2) 

  Computed values wasted

  Why not cache them?
   let fibFast n = 
  let t = new Dictionary<int,int>() 
  let rec fibCached n = 
    if t.ContainsKey(n) then t.[n] 
    else if n <= 2 then 1 
    else let res =  
      fibCached(n‐1) + fibCached(n‐2) 
      t.Add(n,res) 
      res 
  fibCached n 
   Computation expressions = workflows
  builder { expression }
  Usage
  General programming (e.g., seq { … })
  Asynchronous workflows
  Database queries
   Define a builder type
  Computation expression constructs map onto
the builder methods (are de-sugared)
  E.g., let a = b in c  maps onto
  builder.Let(b, (fun a ‐> c)) 
  Builder affects behavior of contained
expressions
  E.g., makes them asynchronous
   Many .NET APIs feature Begin/End pairs
  E.g., BeginGetResponse/EndGetResponse
  Frameworks make code look sequential
  Abstracting away Begin/End calls
  C#  AsyncEnumerator from PowerThreading
  F#  Async workflows
  Goals
  Begin an asynchronous operation
  Resume execution when it’s done
  Let threads interleave
   Async<'a> 
  Represents a result of 'a computed in the future
  This class needs to know about begin/end
pairs
  Extends existing types with XXXAsync() calls
  type WebRequest with 
  member x.GetResponseAsync() =  
    Async.BuildPrimitive( 
      x.BeginGetResponse, 
      x.EndGetResponse) 
   Once Async knows about Begin/End elements
we can use the async { … } workflow
  let download url = 
  async { 
    let rq = WebRequest.Create(url)    
    let! resp = rq.GetResponseAsync() 
    use s = resp.GetResponseStram() 
    use r = new StreamReader(s) 
    r.ReadToEnd() 
  } 
  let! fires off BeginGetResponse() asynchronously
  and waits on completion
   let urls = [ 
  “http://spbalt.net”; 
  “http://sp.ineta.ru”; 
  “http://altdotnet.org” ]

  Spawn one-by-one
  for url in urls do 
  Async.Spawn(download(url))

  Send all at once

  urls |> List.map(fun f ‐> download(f)) 
     |> Async.Parallel |> Async.Run 
   Foundations of F#
Robert Pickering

  Expert F#
Don Syme et al.

  F# for Scientists
Jon Harrop