summaryrefslogtreecommitdiffhomepage
path: root/fsharp.html.markdown
blob: 49951c780355eb12ae354b633466dc90cf7d1b40 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
---
language: F#
contributors:
    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
filename: learnfsharp.fs
---

F# is a general purpose functional/OO programming language.  It's free and open source, and runs on Linux, Mac, Windows and more. 

It has a powerful type system that traps many errors at compile time, but it uses type inference so that it reads more like a dynamic language.

The syntax of F# is different from C-style languages:

* Curly braces are not used to delimit blocks of code. Instead, indentation is used (like Python).
* Whitespace is used to separate parameters rather than commas.

If you want to try out the code below, you can go to [tryfsharp.org](http://www.tryfsharp.org/Create) and paste it into an interactive REPL.

```csharp

// single line comments use a double slash
(* multi line comments use (* . . . *) pair

-end of multi line comment- *)

// ================================================
// Basic Syntax
// ================================================

// ------ "Variables" (but not really) ------
// The "let" keyword defines an (immutable) value
let myInt = 5
let myFloat = 3.14
let myString = "hello"           //note that no types needed

// ------ Lists ------
let twoToFive = [2;3;4;5]        // Square brackets create a list with
                                 // semicolon delimiters.
let oneToFive = 1 :: twoToFive   // :: creates list with new 1st element
// The result is [1;2;3;4;5]
let zeroToFive = [0;1] @ twoToFive   // @ concats two lists

// IMPORTANT: commas are never used as delimiters, only semicolons!

// ------ Functions ------
// The "let" keyword also defines a named function.
let square x = x * x          // Note that no parens are used.
square 3                      // Now run the function. Again, no parens.

let add x y = x + y           // don't use add (x,y)! It means something
                              // completely different.
add 2 3                       // Now run the function.

// to define a multiline function, just use indents. No semicolons needed.
let evens list =
   let isEven x = x%2 = 0     // Define "isEven" as a sub function
   List.filter isEven list    // List.filter is a library function
                              // with two parameters: a boolean function
                              // and a list to work on

evens oneToFive               // Now run the function

// You can use parens to clarify precedence. In this example,
// do "map" first, with two args, then do "sum" on the result.
// Without the parens, "List.map" would be passed as an arg to List.sum
let sumOfSquaresTo100 =
   List.sum ( List.map square [1..100] )

// You can pipe the output of one operation to the next using "|>"
// Piping data around is very common in F#, similar to UNIX pipes.

// Here is the same sumOfSquares function written using pipes
let sumOfSquaresTo100piped =
   [1..100] |> List.map square |> List.sum  // "square" was defined earlier

// you can define lambdas (anonymous functions) using the "fun" keyword
let sumOfSquaresTo100withFun =
   [1..100] |> List.map (fun x -> x*x) |> List.sum

// In F# there is no "return" keyword. A function always
// returns the value of the last expression used.

// ------ Pattern Matching ------
// Match..with.. is a supercharged case/switch statement.
let simplePatternMatch =
   let x = "a"
   match x with
    | "a" -> printfn "x is a"
    | "b" -> printfn "x is b"
    | _ -> printfn "x is something else"   // underscore matches anything

// F# doesn't allow nulls by default -- you must use an Option type
// and then pattern match.  
// Some(..) and None are roughly analogous to Nullable wrappers
let validValue = Some(99)
let invalidValue = None

// In this example, match..with matches the "Some" and the "None",
// and also unpacks the value in the "Some" at the same time.
let optionPatternMatch input =
   match input with
    | Some i -> printfn "input is an int=%d" i
    | None -> printfn "input is missing"

optionPatternMatch validValue
optionPatternMatch invalidValue

// ------ Printing ------
// The printf/printfn functions are similar to the
// Console.Write/WriteLine functions in C#.
printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
printfn "A string %s, and something generic %A" "hello" [1;2;3;4]

// There are also sprintf/sprintfn functions for formatting data
// into a string, similar to String.Format in C#.

// ================================================
// More on functions 
// ================================================

// F# is a true functional language -- functions are first
// class entities and can be combined easy to make powerful
// constructs

// Modules are used to group functions together
// Indentation is needed for each nested module.
module FunctionExamples = 

    // define a simple adding function
    let add x y = x + y
    
    // basic usage of a function
    let a = add 1 2
    printfn "1+2 = %i" a
    
    // partial application to "bake in" parameters
    let add42 = add 42
    let b = add42 1
    printfn "42+1 = %i" b
    
    // composition to combine functions
    let add1 = add 1
    let add2 = add 2
    let add3 = add1 >> add2
    let c = add3 7
    printfn "3+7 = %i" c
    
    // higher order functions
    [1..10] |> List.map add3 |> printfn "new list is %A"
    
    // lists of functions, and more
    let add6 = [add1; add2; add3] |> List.reduce (>>)
    let d = add6 7
    printfn "1+2+3+7 = %i" d

// ================================================
// Lists and collection
// ================================================

// There are three types of ordered collection:
// * Lists are most basic immutable collection. 
// * Arrays are mutable and more efficient when needed. 
// * Sequences are lazy and infinite (e.g. an enumerator). 
//
// Other collections include immutable maps and sets
// plus all the standard .NET collections

module ListExamples = 

    // lists use square brackets 
    let list1 = ["a";"b"]
    let list2 = "c" :: list1    // :: is prepending
    let list3 = list1 @ list2   // @ is concat
    
    // list comprehensions (aka generators)
    let squares = [for i in 1..10 do yield i*i] 

    // prime number generator
    let rec sieve = function
        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
        | []      -> []
    let primes = sieve [2..50]
    printfn "%A" primes 
    
    // pattern matching for lists
    let listMatcher aList = 
        match aList with
        | [] -> printfn "the list is empty" 
        | [first] -> printfn "the list has one element %A " first 
        | [first; second] -> printfn "list is %A and %A" first second 
        | _ -> printfn "the list has more than two elements"    

    listMatcher [1;2;3;4]
    listMatcher [1;2]
    listMatcher [1]
    listMatcher []        

    // recursion using lists
    let rec sum aList = 
        match aList with
        | [] -> 0
        | x::xs -> x + sum xs
    sum [1..10]
    
    // -----------------------------------------    
    // Standard library functions 
    // -----------------------------------------
    
    // map
    let add3 x = x + 3
    [1..10] |> List.map add3

    // filter
    let even x = x % 2 = 0
    [1..10] |> List.filter even
    
    // many more -- see documentation
    
module ArrayExamples = 

    // arrays use square brackets with bar
    let array1 = [| "a";"b" |]
    let first = array1.[0]        // indexed access using dot
   
    // pattern matching for arrays is same as for lists
    let arrayMatcher aList = 
        match aList with
        | [| |] -> printfn "the array is empty" 
        | [| first |] -> printfn "the array has one element %A " first 
        | [| first; second |] -> printfn "array is %A and %A" first second 
        | _ -> printfn "the array has more than two elements"    

    arrayMatcher [| 1;2;3;4 |]

    // Standard library functions just as for List
   
    [| 1..10 |] 
    |> Array.map (fun i -> i+3)
    |> Array.filter (fun i -> i%2 = 0)
    |> Array.iter (printfn "value is %i. ")
    
    
module SequenceExamples = 

    // sequences use curly braces
    let seq1 = seq { yield "a"; yield "b" }
    
    // sequences can use yield and 
    // can contain subsequences
    let strange = seq {
        // "yield! adds one element
        yield 1; yield 2;
        
        // "yield!" adds a whole subsequence
        yield! [5..10]  
        yield! seq {
            for i in 1..10 do 
              if i%2 = 0 then yield i }}
    // test                
    strange |> Seq.toList              
              

    // Sequences can be created using "unfold"
    // Here's the fibonacci series
    let fib = Seq.unfold (fun (fst,snd) ->
        Some(fst + snd, (snd, fst + snd))) (0,1)

    // test                        
    let fib10 = fib |> Seq.take 10 |> Seq.toList
    printf "first 10 fibs are %A" fib10     
   
    
// ================================================
// Data Types 
// ================================================

module DataTypeExamples = 

    // All data is immutable by default

    // Tuples are quick 'n easy anonymous types
    // -- Use a comma to create a tuple
    let twoTuple = 1,2
    let threeTuple = "a",2,true
    
    // Pattern match to unpack
    let x,y = twoTuple  //sets x=1 y=2

    // ------------------------------------ 
    // Record types have named fields 
    // ------------------------------------ 

    // Use "type" with curly braces to define a record type
    type Person = {First:string; Last:string}
    
    // Use "let" with curly braces to create a record 
    let person1 = {First="John"; Last="Doe"}

    // Pattern match to unpack
    let {First=first} = person1    //sets first="john"

    // ------------------------------------ 
    // Union types (aka variants) have a set of choices
    // Only case can be valid at a time.
    // ------------------------------------ 

    // Use "type" with bar/pipe to define a union type
    type Temp = 
        | DegreesC of float
        | DegreesF of float
        
    // Use one of the cases to create one
    let temp1 = DegreesF 98.6
    let temp2 = DegreesC 37.0

    // Pattern match on all cases to unpack
    let printTemp = function
       | DegreesC t -> printfn "%f degC" t
       | DegreesF t -> printfn "%f degF" t
    
    printTemp temp1 
    printTemp temp2

    // ------------------------------------ 
    // Recursive types
    // ------------------------------------ 

    // Types can be combined recursively in complex ways 
    // without having to create subclasses
    type Employee = 
      | Worker of Person
      | Manager of Employee list

    let jdoe = {First="John";Last="Doe"}
    let worker = Worker jdoe
    
    // ------------------------------------ 
    // Modelling with types
    // ------------------------------------ 
    
    // Union types are great for modelling state without using flags
    type EmailAddress = 
        | ValidEmailAddress of string
        | InvalidEmailAddress of string

    let trySendEmail email =
        match email with // use pattern matching
        | ValidEmailAddress address -> ()   // send
        | InvalidEmailAddress address -> () // dont send

    // The combination of union types and record types together
    // provide a great foundation for domain driven design.
    // You can create hundreds of little types that accurately 
    // reflect the domain.

    type CartItem = { ProductCode: string; Qty: int }
    type Payment = Payment of float
    type ActiveCartData = { UnpaidItems: CartItem list }
    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
        
    type ShoppingCart = 
        | EmptyCart  // no data
        | ActiveCart of ActiveCartData
        | PaidCart of PaidCartData    

    // ------------------------------------ 
    // Built in behavior for types
    // ------------------------------------ 

    // Core types have useful "out-of-the-box" behavior, no coding needed.
    // * Immutability
    // * Pretty printing when debugging
    // * Equality and comparison
    // * Serialization
        
    // Pretty printing using %A
    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A" 
             twoTuple person1 temp1 worker

    // Equality and comparison built in.
    // Here's an example with cards.
    type Suit = Club | Diamond | Spade | Heart
    type Rank = Two | Three | Four | Five | Six | Seven | Eight 
                | Nine | Ten | Jack | Queen | King | Ace    

    let hand = [ Club,Ace; Heart,Three; Heart,Ace; 
                 Spade,Jack; Diamond,Two; Diamond,Ace ]

    // sorting
    List.sort hand |> printfn "sorted hand is (low to high) %A"
    List.max hand |> printfn "high card is %A"
    List.min hand |> printfn "low card is %A"

             
// ================================================
// Active patterns
// ================================================

module ActivePatternExamples = 

    // F# has a special type of pattern matching called "active patterns" 
    // where the pattern can be parsed or detected dynamically. 

    // "banana clips" are the syntax for active patterns
    
    // for example, define an "active" pattern to match character types...
    let (|Digit|Letter|Whitespace|Other|) ch = 
       if System.Char.IsDigit(ch) then Digit
       else if System.Char.IsLetter(ch) then Letter
       else if System.Char.IsWhiteSpace(ch) then Whitespace
       else Other         

    // ... and then use it to make parsing logic much clearer
    let printChar ch = 
      match ch with
      | Digit -> printfn "%c is a Digit" ch
      | Letter -> printfn "%c is a Letter" ch
      | Whitespace -> printfn "%c is a Whitespace" ch
      | _ -> printfn "%c is something else" ch

    // print a list
    ['a';'b';'1';' ';'-';'c'] |> List.iter printChar

    // -----------------------------------
    // FizzBuzz using active patterns
    // -----------------------------------
    
    // You can create partial matching patterns as well
    // Just use undercore in the defintion, and return Some if matched.
    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None

    // the main function
    let fizzBuzz i = 
      match i with
      | MultOf3 & MultOf5 -> printf "FizzBuzz, " 
      | MultOf3 -> printf "Fizz, " 
      | MultOf5 -> printf "Buzz, " 
      | _ -> printf "%i, " i
      
    // test
    [1..20] |> List.iter fizzBuzz 
    
// ================================================
// Conciseness 
// ================================================

module AlgorithmExamples = 

    // F# has a high signal/noise ratio, so code reads 
    // almost like the actual algorithm

    // ------ Example: define sumOfSquares function ------
    let sumOfSquares n = 
       [1..n]              // 1) take all the numbers from 1 to n
       |> List.map square  // 2) square each one
       |> List.sum         // 3) sum the results

    // test   
    sumOfSquares 100 |> printfn "Sum of squares = %A" 
       
    // ------ Example: define a sort function ------  
    let rec sort list =
       match list with
       // If the list is empty   
       | [] ->                            
            []                            // return an empty list
       // If the list is not empty  
       | firstElem::otherElements ->      // take the first element    
            let smallerElements =         // extract the smaller elements    
                otherElements             // from the remaining ones
                |> List.filter (fun e -> e < firstElem) 
                |> sort                   // and sort them
            let largerElements =          // extract the larger ones
                otherElements             // from the remaining ones
                |> List.filter (fun e -> e >= firstElem)
                |> sort                   // and sort them
            // Combine the 3 parts into a new list and return it
            List.concat [smallerElements; [firstElem]; largerElements]

    // test
    sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A" 

// ================================================
// Asynchronous Code
// ================================================

module AsyncExample = 

    // F# has built-in features to help with async code
    // without encountering the "pyramid of doom"
    //
    // The following example downloads a set of web pages in parallel.

    open System.Net
    open System
    open System.IO
    open Microsoft.FSharp.Control.CommonExtensions   

    // Fetch the contents of a URL asynchronously
    let fetchUrlAsync url =        
        async {   // "async" keyword and curly braces 
                  // creates an "async" object
            let req = WebRequest.Create(Uri(url)) 
            use! resp = req.AsyncGetResponse()    
                // use! is async assignment
            use stream = resp.GetResponseStream() 
                // "use" triggers automatic close()
                // on resource at end of scope
            use reader = new IO.StreamReader(stream) 
            let html = reader.ReadToEnd() 
            printfn "finished downloading %s" url 
            }
            
    // a list of sites to fetch
    let sites = ["http://www.bing.com";
                 "http://www.google.com";
                 "http://www.microsoft.com";
                 "http://www.amazon.com";
                 "http://www.yahoo.com"]

    // do it
    sites 
    |> List.map fetchUrlAsync  // make a list of async tasks
    |> Async.Parallel          // set up the tasks to run in parallel
    |> Async.RunSynchronously  // start them off

// ================================================
// .NET compatability
// ================================================

module NetCompatibilityExamples = 

    // F# can do almost everything C# can do, and it integrates
    // seamlessly with .NET or Mono libraries.

    // ------- work with existing library functions  -------
    
    let (i1success,i1) = System.Int32.TryParse("123");
    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"

    // ------- Implement interfaces on the fly! -------
    
    // create a new object that implements IDisposable
    let makeResource name = 
       { new System.IDisposable 
         with member this.Dispose() = printfn "%s disposed" name }

    let useAndDisposeResources = 
        use r1 = makeResource "first resource"
        printfn "using first resource" 
        for i in [1..3] do
            let resourceName = sprintf "\tinner resource %d" i
            use temp = makeResource resourceName 
            printfn "\tdo something with %s" resourceName 
        use r2 = makeResource "second resource"
        printfn "using second resource" 
        printfn "done." 

    // ------- Object oriented code -------
    
    // F# is also a fully fledged OO language.
    // It supports classes, inheritance, virtual methods, etc.

    // interface with generic type
    type IEnumerator<'a> = 
        abstract member Current : 'a
        abstract MoveNext : unit -> bool 

    // abstract base class with virtual methods
    [<AbstractClass>]
    type Shape() = 
        //readonly properties
        abstract member Width : int with get
        abstract member Height : int with get
        //non-virtual method
        member this.BoundingArea = this.Height * this.Width
        //virtual method with base implementation
        abstract member Print : unit -> unit 
        default this.Print () = printfn "I'm a shape"

    // concrete class that inherits from base class and overrides 
    type Rectangle(x:int, y:int) = 
        inherit Shape()
        override this.Width = x
        override this.Height = y
        override this.Print ()  = printfn "I'm a Rectangle"

    //test
    let r = Rectangle(2,3)
    printfn "The width is %i" r.Width
    printfn "The area is %i" r.BoundingArea
    r.Print()        

    // ------- extension methods  -------
        
    //Just as in C#, F# can extend existing classes with extension methods.
    type System.String with
       member this.StartsWithA = this.StartsWith "A"

    //test
    let s = "Alice"
    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA    
    
    // ------- events  -------
   
    type MyButton() =
        let clickEvent = new Event<_>()

        [<CLIEvent>]
        member this.OnClick = clickEvent.Publish

        member this.TestEvent(arg) =
            clickEvent.Trigger(this, arg)

    // test
    let myButton = new MyButton()
    myButton.OnClick.Add(fun (sender, arg) -> 
            printfn "Click event with arg=%O" arg)

    myButton.TestEvent("Hello World!")
        
```

## More Information

For more demonstrations of F#, go to the [Try F#](http://www.tryfsharp.org/Learn) site, or my [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) series.

Read more about F# at [fsharp.org](http://fsharp.org/).