anchor.diff:      printfn "Struct Tuple: %A\nReference tuple made from the Struct Tuple: %A" sampleStructTuple (sampleStructTuple |> convertFromStructTuple)
   
   
  +/// The F# pipe operators ('|>', '<|', etc.) and F# composition operators ('>>', '<<')
  +/// are used extensively when processing data.  These operators are themselves functions
  +/// which make use of Partial Application.
  +///
  +/// To learn more about these operators, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#function-composition-and-pipelining
  +/// To learn more about Partial Application, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#partial-application-of-arguments
  +module PipelinesAndComposition =
  +
  +    /// Squares a value.
  +    let square x = x * x
  +
  +    /// Adds 1 to a value.
  +    let addOne x = x + 1
  +
  +    /// Tests if an integer value is odd via modulo.
  +    let isOdd x = x % 2 <> 0
  +
  +    /// A list of 5 numbers.  More on lists later.
  +    let numbers = [ 1; 2; 3; 4; 5 ]
  +
  +    /// Given a list of integers, it filters out the even numbers,
  +    /// squares the resulting odds, and adds 1 to the squared odds.
  +    let squareOddValuesAndAddOne values = 
  +        let odds = List.filter isOdd values
  +        let squares = List.map square odds
  +        let result = List.map addOne squares
  +        result
  +    
  +    /// A shorter way to write 'squareOddValuesAndAddOne' is to nest each
  +    /// sub-result into the function calls themselves.
  +    ///
  +    /// This makes the function much shorter, but it's difficult to see the
  +    /// order in which the data is processed.
  +    let squareOddValuesAndAddOneNested values = 
  +        List.map addOne (List.map square (List.filter isOdd values))
  +
  +    /// A preferred way to write 'squareOddValuesAndAddOne' is to use F# pipe operators.
  +    /// This allows you to avoid creating intermediate results, but is much more readable
  +    /// than nesting function calls like 'squareOddValuesAndAddOneNested'
  +    let squareOddValuesAndAddOnePipeline values =
  +        values
  +        |> List.filter isOdd
  +        |> List.map square
  +        |> List.map addOne
  +
  +    /// You can shorten 'squareOddValuesAndAddOnePipeline' by moving the second `List.map` call
  +    /// into the first, using a Lambda Function.
  +    ///
  +    /// Note that pipelines are also being used inside the lambda function.  F# pipe operators
  +    /// can be used for single values as well.  This makes them very powerful for processing data.
  +    let squareOddValuesAndAddOneShorterPipeline values =
  +        values
  +        |> List.filter isOdd
  +        |> List.map(fun x -> x |> square |> addOne)
  +
  +    /// Lastly, you can eliminate the need to explicitly take 'values' in as a parameter by using '>>'
  +    /// to compose the two core operations: filtering out even numbers, then squaring and adding one.
  +    /// Likewise, the 'fun x -> ...' bit of the lambda expression is also not needed, because 'x' is simply
  +    /// being defined in that scope so that it can be passed to a functional pipeline.  Thus, '>>' can be used
  +    /// there as well.
  +    ///
  +    /// The result of 'squareOddValuesAndAddOneComposition' is itself another function which takes a
  +    /// list of integers as its input.  If you execute 'squareOddValuesAndAddOneComposition' with a list
  +    /// of integers, you'll notice that it produces the same results as previous functions.
  +    ///
  +    /// This is using what is known as function composition.  This is possible because functions in F#
  +    /// use Partial Application and the input and output types of each data processing operation match
  +    /// the signatures of the functions we're using.
  +    let squareOddValuesAndAddOneComposition =
  +        List.filter isOdd >> List.map (square >> addOne)
  +
  +
   /// Lists are ordered, immutable, singly-linked lists.  They are eager in their evaluation.
   /// 
   /// This module shows various ways to generate lists and process lists with some functions
  
positive.code:     open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
  
      /// Define a unitized constant
      let sampelValue1 = 1600.0<meter>          
  
      /// Next, define a new unit type
      [<Measure>]
  
negative.code:     /// Lists are defined using [ ... ].  This is an empty list.
      let list1 = [ ]  
  
      /// This is a list with 3 elements.  ';' is used to separate elements on the same line.
      let list2 = [ 1; 2; 3 ]
  
      /// You can also separate elements by placing them on their own lines.
      let list3 = [
          1
          2
          3
      ]
  
      /// This is a list of integers from 1 to 1000
      let numberList = [ 1 .. 1000 ]  
  