anchor.diff:  
           // Append the lookahead symbol, if applicable.
           if typeof<'Lookahead> <> typeof<unit> then
  -            sb.Append ", " |> ignore
  -            this.Lookahead.ToString () |> sb.Append |> ignore
  +            sprintf ", %A" this.Lookahead
  +            |> sb.Append |> ignore
   
           sb.ToString ()
   
  
positive.code:                             LrTableGenState.reductionRuleId (item.Nonterminal, item.Production) tableGenState
  
                          // Add 'reduce' actions to the parser table.
                          Lr0TableGenState.reduce stateId reductionRuleId grammar.Terminals tableGenState
                          // TEMP : Discard the unit return value until we can use a monadic fold.
                          |> snd
                      else
  
negative.code:     when 'Nonterminal : comparison
      and 'Terminal : comparison> =
      LrTableGenState<'Nonterminal, 'Terminal, unit>
  
  /// LR(0) parser tables.
  [<RequireQualifiedAccess>]
  module internal Lr0 =
      /// Functions for manipulating LR(0) parser items.
      [<RequireQualifiedAccess>]
      module Item =
          /// Computes the LR(0) closure of a set of items.
          // TODO : Modify this to use a worklist-style algorithm to avoid
          // reprocessing items which already exist in the set (i.e., when iterating,
          // we only process items added to the set in the previous iteration).
          let closure (productions : Map<'Nonterminal, Symbol<'Nonterminal, 'Terminal>[][]>) items =
              /// Implementation of the LR(0) closure algorithm.
              let rec closure items =
                  let items' =
                      (items, items)
                      ||> Set.fold (fun items item ->
                          // If the position is at the end of the production,
                          // there's nothing that needs to be done for this item.
                          if int item.Position = Array.length item.Production then
                              items
                          else
                              // Determine what to do based on the next symbol to be parsed.
                              match item.Production.[int item.Position] with
                              | Symbol.Terminal _ ->
                                  // Nothing to do for terminals
                                  items
                              | Symbol.Nonterminal nontermId ->
                                  /// The productions of this nonterminal.
                                  let nontermProductions = Map.find nontermId productions
  
                                  // For all productions of this nonterminal, create a new item
                                  // with the parser position at the beginning of the production.
                                  // Add these new items into the set of items.
                                  (items, nontermProductions)
                                  ||> Array.fold (fun items production ->
                                      let newItem = {
                                          Nonterminal = nontermId;
                                          Production = production;
                                          Position = GenericZero;
                                          Lookahead = (); }
  
                                      Set.add newItem items))
  
                  // If the items set has changed, recurse for another iteration.
                  // If not, we're done processing and the set is returned.
                  if items' = items then
                      items
                  else
                      closure items'
  
              // Compute the closure, starting with the specified initial item.
              closure items
  
          /// Moves the 'dot' (the current parser position) past the
          /// specified symbol for each item in a set of items.
          let goto symbol items (productions : Map<'Nonterminal, Symbol<'Nonterminal, 'Terminal>[][]>) =
              /// The updated 'items' set.
              let items =
                  (Set.empty, items)
                  ||> Set.fold (fun updatedItems item ->
                      // If the position is at the end of the production, we know
                      // this item can't be a match, so continue to to the next item.
                      if int item.Position = Array.length item.Production then
                          updatedItems
                      else
                          // If the next symbol to be parsed in the production is the
                          // specified symbol, create a new item with the position advanced
                          // to the right of the symbol and add it to the updated items set.
                          if item.Production.[int item.Position] = symbol then
                              let updatedItem =
                                  { item with
                                      Position = item.Position + 1<_>; }
                              Set.add updatedItem updatedItems
                          else
                              // The symbol did not match, so this item won't be added to
                              // the updated items set.
                              updatedItems)
  
              // Return the closure of the item set.
              closure productions items
  
      /// Functions which use the State monad to manipulate an LR(0) table-generation state.
      [<RequireQualifiedAccess>]
      module TableGenState =
          /// Add 'reduce' actions to the parser table for each terminal (token) in the grammar.
          let reduce (sourceState : ParserStateId)
                      (reductionRuleId : ReductionRuleId)
                      (terminals : Set<_>)
                      (tableGenState : Lr0TableGenState<'Nonterminal, AugmentedTerminal<'Terminal>>) =
              // Fold over the set of terminals (tokens) in the grammar.
              let table =
                  (tableGenState.Table, terminals)
                  ||> Set.fold (fun table token ->
                      //
                      let tableKey = sourceState, Symbol.Terminal token
  
                      //
                      let entry =
                          let action = LrParserAction.Reduce reductionRuleId
                          match Map.tryFind tableKey table with
                          | None ->
                              Set.singleton action
                          | Some entry ->
                              Set.add action entry
  
                      // Update the table with the entry.
                      Map.add tableKey entry table)
  
              // Return the updated table-gen state.
              (),
              { tableGenState with
                  Table = table; }
  
  
      //
      let rec private createTableImpl grammar (tableGenState : Lr0TableGenState<'Nonterminal, AugmentedTerminal<'Terminal>>) =
          // Preconditions
  