anchor.diff:  //
   // For more about F#, see:
   //     http://fsharp.org
  +//     https://docs.microsoft.com/en-us/dotnet/articles/fsharp/
  +//
  +// To learn more about applied F# programming, use
  +//     http://fsharp.org/guides/enterprise/
  +//     http://fsharp.org/guides/cloud/
  +//     http://fsharp.org/guides/web/
  +//     http://fsharp.org/guides/data-science/
  +//
  +// To install the Visual F# Power Tools, use
  +//     'Tools' --> 'Extensions and Updates' --> `Online` and search
   //
   // For additional templates to use with F#, see the 'Online Templates' in Visual Studio, 
   //     'New Project' --> 'Online Templates'
  -//
  -// For specific F# topics, see:
  -//     http://go.microsoft.com/fwlink/?LinkID=234174 (F# Development Portal)
  -//     http://go.microsoft.com/fwlink/?LinkID=124614 (Code Gallery)
  -//     http://go.microsoft.com/fwlink/?LinkId=235173 (Math/Stats Programming)
  -//     http://go.microsoft.com/fwlink/?LinkId=235176 (Charting)
  -
  -// Contents:
  -//    - Integers and basic functions
  -//    - Booleans
  -//    - Strings
  -//    - Tuples
  -//      struct Tuples
  -//    - Lists and list processing
  -//    - Classes
  -//    - Generic classes
  -//    - Implementing interfaces
  -//    - Arrays
  -//    - Sequences
  -//    - Recursive functions
  -//    - Record types
  -//    - Union types
  -//    - Option types
  -//    - Pattern matching
  -//    - Units of measure
  -//    - Parallel array programming
  -//    - Using events
  -//    - Database access using type providers
  -//    - OData access using type providers
  -
  -
  -
  -// ---------------------------------------------------------------
  -//         Integers and basic functions
  -// ---------------------------------------------------------------
  -
  -module Integers = 
  +
  +
  +// Open namespaces using 'open'
  +open System
  +
  +
  +/// First some basics on integers and numbers
  +module IntegersAndNumbers = 
  +
  +    /// This is a sample integer.
       let sampleInteger = 176
   
  -    /// Do some arithmetic starting with the first integer
  -    let sampleInteger2 = (sampleInteger/4 + 5 - 7) * 4
  -
  -    /// A list of the numbers from 0 to 99
  +    /// This is a sample floating point number.
  +    let sampleDouble = 4.1
  +
  +    /// This computed a new number by some arithmetic.  Numeric types are converted using
  +    /// functions 'int', 'double' and so on.
  +    let sampleInteger2 = (sampleInteger/4 + 5 - 7) * 4 + int sampleDouble
  +
  +    /// This is a list of the numbers from 0 to 99.
       let sampleNumbers = [ 0 .. 99 ]
   
  -    /// A list of all tuples containing all the numbers from 0 to 99 and their squares
  +    /// This is a list of all tuples containing all the numbers from 0 to 99 and their squares.
       let sampleTableOfSquares = [ for i in 0 .. 99 -> (i, i*i) ]
   
       // The next line prints a list that includes tuples, using %A for generic printing
       printfn "The table of squares from 0 to 99 is:\n%A" sampleTableOfSquares
   
   
  +/// Much of F# programming consists of defining functions that transform input data to produce
  +/// useful resutls.
   module BasicFunctions = 
   
  -    // Use 'let' to define a function that accepts an integer argument and returns an integer. 
  -    let func1 x = x*x + 3
  -
  -    // Parenthesis are optional for function arguments
  -    let func1a (x) = x*x + 3
  +    /// You use 'let' to define a function that accepts an integer argument and returns an integer. 
  +    /// Parentheses are optional for function arguments,
  +    let sampleFunction1 x = x*x + 3
   
       /// Apply the function, naming the function return result using 'let'. 
       /// The variable type is inferred from the function return type.
  -    let result1 = func1 4573
  +    let result1 = sampleFunction1 4573
       printfn "The result of squaring the integer 4573 and adding 3 is %d" result1
   
  -    // When needed, annotate the type of a parameter name using '(argument:type)'
  -    let func2 (x:int) = 2*x*x - x/5 + 3
  -
  -    let result2 = func2 (7 + 4)
  +    /// When needed, annotate the type of a parameter name using '(argument:type)'
  +    let sampleFunction2 (x:int) = 2*x*x - x/5 + 3
  +
  +    let result2 = sampleFunction2 (7 + 4)
       printfn "The result of applying the 1st sample function to (7 + 4) is %d" result2
   
  -    let func3 x = 
  +    /// Conditionals use if/then/elid/elif/else.
  +    ///
  +    /// Note that F# uses whitespace indentation-aware syntax like Python.
  +    let sampleFunction3 x = 
           if x < 100.0 then 
               2.0*x*x - x/5.0 + 3.0
           else 
               2.0*x*x + x/5.0 - 37.0
   
  -    let result3 = func3 (6.5 + 4.5)
  +    let result3 = sampleFunction3 (6.5 + 4.5)
       printfn "The result of applying the 2nd sample function to (6.5 + 4.5) is %f" result3
   
   
   
  -// ---------------------------------------------------------------
  -//         Booleans
  -// ---------------------------------------------------------------
  -
  -module SomeBooleanValues = 
  -
  +/// Strings and booleans are fundamental data types in F# programming.
  +module StringManipulation = 
  +
  +    /// Booleans use 'true', 'false', 'not', '&&' and '||'
       let boolean1 = true
       let boolean2 = false
   
  
positive.code: 
      printfn "The expression 'not boolean1 && (boolean2 || false)' is %A" boolean3
  
  
  
  // ---------------------------------------------------------------
  //         Strings
  // ---------------------------------------------------------------
  
  module StringManipulation = 
  
      let string1 = "Hello"
      let string2  = "world"
  
      /// Use @ to create a verbatim string literal
      let string3 = @"c:\Program Files\"
  
      /// Using a triple-quote string literal
      let string4 = """He said "hello world" after you did"""
  
      let helloWorld = string1 + " " + string2 // concatenate the two strings with a space in between
      printfn "%s" helloWorld
  
      /// A string formed by taking the first 7 characters of one of the result strings
      let substring = helloWorld.[0..6]
      printfn "%s" substring
  
  
  
  // ---------------------------------------------------------------
  //         Tuples (ordered sets of values)
  // ---------------------------------------------------------------
  
  module Tuples = 
  
      /// A simple tuple of integers
      let tuple1 = (1, 2, 3)
  
      /// A function that swaps the order of two values in a tuple. 
      /// QuickInfo shows that the function is inferred to have a generic type.
      let swapElems (a, b) = (b, a)
  
      printfn "The result of swapping (1, 2) is %A" (swapElems (1,2))
  
negative.code: 
  
  
  
  /// Recursive functions can call themselves. In F#, functions are only recursive
  /// when declared using 'let rec'.  The members of a set of type declarations are
  /// always implicitly recursive. Entire namespaces and modules can be made recursive
  /// through 'namespace rec' and 'module rec'.
  module RecursiveFunctions  = 
                
      /// This example shows a recursive function that computes the factorial of an 
      /// integer. It uses 'let rec' to define a recursive function.
      let rec factorial n = 
          if n = 0 then 1 else n * factorial (n-1)
  
      /// This example shows a recursive function that computes the greatest common factor of two integers. 
      //  Since all of the recursive calls are tail calls, the compiler will turn the function into a loop,
      //  which improves performance and reduces memory consumption.
      let rec greatestCommonFactor a b =
  