anchor.diff:          abstract GetState : ZipCode -> string option
           abstract GetShippingZone : string -> int
   
  -    /// Next calculate a shipping zone for a customer using a calculator instance.
  +    /// Next, calculate a shipping zone for a customer using a calculator instance.
  +    /// This uses combinators in the Option module to allow a functional pipeline for
  +    /// transforming data with Optionals.
       let CustomerShippingZone (calculator: ShippingCalculator, customer: Customer) =
  -        customer.ZipCode |> Option.bind calculator.GetState |> Option.map calculator.GetShippingZone
  -
  -
  -
  -/// Numeric types can be annotated with units.  F# arithmetic correctly computes the adjusted
  -/// numeric types.
  +        customer.ZipCode 
  +        |> Option.bind calculator.GetState 
  +        |> Option.map calculator.GetShippingZone
  +
  +
  +/// Units of measure are a way to annotate primitive numeric types in a type-safe way.
  +/// You can then perform type-safe arithmetic on these values.
  +///
  +/// To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/units-of-measure
   module UnitsOfMeasure = 
   
  -    /// First open a collection of common unit names
  +    /// First, open a collection of common unit names
       open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
   
       /// Define a unitized constant
  -    let sampelValue1  = 1600.0<meter>          
  +    let sampelValue1 = 1600.0<meter>          
   
       /// Next, define a new unit type
       [<Measure>]
  
positive.code:             2.0*x*x + x/5.0 - 37.0
  
      let result3 = sampleFunction3 (6.5 + 4.5)
      printfn "The result of applying the 2nd sample function to (6.5 + 4.5) is %f" result3
  
  
  
  /// Strings and booleans are fundamental data types in F# programming.
  module StringManipulation = 
  
      /// Booleans use 'true', 'false', 'not', '&&' and '||'
      let boolean1 = true
      let boolean2 = false
  
      let boolean3 = not boolean1 && (boolean2 || false)
  
      printfn "The expression 'not boolean1 && (boolean2 || false)' is %A" boolean3
  
      /// Strings use double quotes.
      let string1 = "Hello"
      let string2  = "world"
  
      /// Strings can also use @ to create a verbatim string literal
      let string3 = @"c:\Program Files\"
  
      /// String literals can also use triple-quotes
      let string4 = """He said "hello world" after you did"""
  
      /// String concatenation is '+'. Also see String.concat, System.String.Join and others.
      let helloWorld = string1 + " " + string2 
      printfn "%s" helloWorld
  
      /// Substrings use the indexer notation, for example the first 7 characters.
      let substring = helloWorld.[0..6]
      printfn "%s" substring
  
  
  
  /// Tuples are simple combinations of data values into a combined value.
  module Tuples = 
  
      /// First define a simple tuple of integers.
      let tuple1 = (1, 2, 3)
  
      /// Next you define a function that swaps the order of two values in a tuple. 
      /// 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))
  
      /// A tuple consisting of an integer, a string, and a double-precision floating point number
      let tuple2 = (1, "fred", 3.1415)
  
      printfn "tuple1: %A    tuple2: %A" tuple1 tuple2
  
      /// A simple tuple of integers, represented as a flat inline struct (a value-type)
      let sampleStructTuple = struct (1, 2, 3)
  
  
  // ---------------------------------------------------------------
  //         Lists, Arrays and data processing
  // ---------------------------------------------------------------
  
  /// Lists, arrays and sequences are basic collection types in F# programming.
  /// Many other collection types are available in System.Collections.Generic,
  /// System.Collections.Immutable and other libraries.
  module ListsAndArrays = 
  
      /// Lists are defined using [ ... ].  This is an empty list.
      let list1 = [ ]  
  
      /// This is a list with 3 elements.
      let list2 = [ 1; 2; 3 ]
  
      /// This is a list of integers from 1 to 1000
  
negative.code:     /// This is an array of numbers from 1 to 1000.
      let array3 = [| 1 .. 1000 |]
  
      /// This is an array containing only the words "hello" and "world".
      let array4 = 
          [| for word in array2 do
                 if word.Contains("l") then 
                     yield word |]
  
      /// This is an array initialized by index and containing the even numbers from 0 to 2000.
      let evenNumbers = Array.init 1001 (fun n -> n * 2) 
  
      /// Sub-arrays are extracted using slicing notation.
      let evenNumbersSlice = evenNumbers.[0..500]
  
      /// You can loop over arrays and lists using 'for' loops.
      for word in array4 do 
          printfn "word: %s" word
  
      // You can modify the contents of an an array element by using the left arrow assignment operator.
      //
      // To learn more about this operator, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/values/index#mutable-variables
      array2.[1] <- "WORLD!"
  
      /// You can transform arrays using 'Array.map' and other functional programming operations.
      /// The following calculates the sum of the lengths of the words that start with 'h'.
      let sumOfLengthsOfWords = 
          array2
          |> Array.filter (fun x -> x.StartsWith "h")
          |> Array.sumBy (fun x -> x.Length)
  
      printfn "The sum of the lengths of the words in Array 2 is: %d" sumOfLengthsOfWords
  
  
  /// Sequences are a logical series of elements, all of the same type.  These are a more general type than Lists and Arrays.
  ///
  /// Sequences are evaluated on-demand and are re-evaluated each time they are iterated. 
  /// An F# sequence is an alias for a .NET System.Collections.Generic.IEnumerable<'T>.
  ///
  /// Sequence processing functions can be applied to Lists and Arrays as well.
  ///
  /// To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/sequences
  module Sequences = 
  
      /// This is the empty sequence.
  