anchor.diff:      /// Compute  metric-system constant
       let sampleValue3 = sampleValue2 * mile.asMeter   
   
  -    printfn "After a %A race I would walk %A miles which would be %A meters" sampelValue1 sampleValue2 sampleValue3
  -
  +    // Values using Units of Measure can be used just like the primitive numeric type for things like printing.
  +    printfn "After a %f race I would walk %f miles which would be %f meters" sampelValue1 sampleValue2 sampleValue3
  +
  +
  +/// Classes are a way of defining new object types in F#, and support standard Object-oriented constructs.
  +/// Classes can have a variety of members (methods, properties, events, etc.)
  +///
  +/// To learn more about Classes, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/classes
  +///
  +/// To learn more about Members, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/members
  +module DefiningClasses = 
  +
  +    /// A simple two-dimensional Vector class.
  +    ///
  +    /// The class's constructor is on the first line,
  +    /// and takes two arguments: dx and dy, both of type 'double'.
  +    type Vector2D(dx : double, dy : double) =
  +
  +        /// This internal field stores the length of the vector, computed when the 
  +        /// object is constructed
  +        let length = sqrt (dx*dx + dy*dy)
  +
  +        // 'this' specifies a name for the object's self identifier.
  +        // In instance methods, it must appear before the member name.
  +        member this.DX = dx
  +
  +        member this.DY = dy
  +
  +        member this.Length = length
  +
  +        /// This member is a method.  The previous members were properties.
  +        member this.Scale(k) = Vector2D(k * this.DX, k * this.DY)
  +    
  +    /// This is how you instantiate the Vector2D class.
  +    let vector1 = Vector2D(3.0, 4.0)
  +
  +    /// Get a new scaled vector object, without modifying the original object.
  +    let vector2 = vector1.Scale(10.0)
  +
  +    printfn "Length of vector1: %f\nLength of vector2: %f" vector1.Length vector2.Length
  +
  +
  +/// Generic classes allow types to be defined with respect to a set of type parameters.
  +/// In the followiung, 'T is the type parameter for the class.
  +///
  +/// To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/generics/
  +module DefiningGenericClasses = 
  +
  +    type StateTracker<'T>(initialElement: 'T) = 
  +
  +        /// This internal field store the states in a list.
  +        let mutable states = [ initialElement ]
  +
  +        /// Add a new element to the list of states.
  +        member this.UpdateState newState = 
  +            states <- newState :: states  // use the '<-' operator to mutate the value.
  +
  +        /// Get the entire list of historical states.
  +        member this.History = states
  +
  +        /// Get the latest state.
  +        member this.Current = states.Head
  +
  +    /// An 'int' instance of the state tracker class. Note that the type parameter is inferred.
  +    let tracker = StateTracker 10
  +
  +    // Add a state
  +    tracker.UpdateState 17
  +
  +
  +/// Interfaces are object types with only 'abstract' members.
  +/// Object types and object expressions can implement interfaces.
  +///
  +/// To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/interfaces
  +module ImplementingInterfaces = 
  +
  +    /// This is a type that implements IDisposable.
  +    type ReadFile() =
  +
  +        let file = new System.IO.StreamReader("readme.txt")
  +
  +        member this.ReadLine() = file.ReadLine()
  +
  +        // This is the implementation of IDisposable members.
  +        interface System.IDisposable with
  +            member this.Dispose() = file.Close()
  +
  +
  +    /// This is an object that implements IDisposable via an Object Expression
  +    /// Unlike other languages such as C# or Java, a new type definition is not needed 
  +    /// to implement an interface.
  +    let interfaceImplementation =
  +        { new System.IDisposable with
  +            member this.Dispose() = printfn "disposed" }
   
   
   /// The FSharp.Core library defines a range of parallel processing functions.  Here
   /// you use some functions for parallel processing over arrays.
  +///
  +/// To learn more, see: https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/array.parallel-module-%5Bfsharp%5D
   module ParallelArrayProgramming = 
                 
  -    ///
       /// First, an array of inputs.
       let oneBigArray = [| 0 .. 100000 |]
       
  
positive.code:     /// all the days of the year.
      let daysList = 
          [ for month in 1 .. 12 do
                for day in 1 .. System.DateTime.DaysInMonth(2012, month) do 
                    yield System.DateTime(2012, month, day) ]
  
      /// Computations can include conditionals.  This is a list containing the tuples
      /// which are the coordinates of the black squares on a chess board.
  
negative.code:     /// 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 results.
  ///
  /// To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/
  module BasicFunctions = 
  
      /// You use 'let' to define a function. This one accepts an integer argument and returns an integer. 
      /// Parentheses are optional for function arguments, except for when you use an explicit type annotation.
      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 = sampleFunction1 4573
  
      // This line uses '%d' to print the result as an integer. This is type-safe.
      // If 'result1' were not of type 'int', then the line would fail to compile.
      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)'.  Parentheses are required.
      let sampleFunction2 (x:int) = 2*x*x - x/5 + 3
  
      let result2 = sampleFunction2 (7 + 4)
  