anchor.diff:                                          let ithSymbolFollowSet' =
                                               /// The FOLLOW set for the current nonterminal.
                                               let nontermFollowSet = Map.find nontermId followSets
  -
  +                                            // Merge it with the FOLLOW set for the i-th symbol.
                                               Set.union ithSymbolFollowSet nontermFollowSet
   
                                           // Set the 'updated' flag iff the i-th symbol's FOLLOW set
  
positive.code:                         let mutable updated = updated
  
                          for i = 0 to Array.length production - 1 do
                              if i = 0 ||
                                  // OPTIMIZE : Array slices are slow -- find another way to implement this.
                                  production.[0 .. i - 1]
                                  |> Array.forall (function
                                      | Symbol.Terminal _ ->
                                          false
                                      | Symbol.Nonterminal nontermId ->
                                          Map.find nontermId nullable) then
  
                                  /// The FIRST set for the current nonterminal.
                                  let nontermFirstSet = Map.find nontermId firstSets
                                  /// The FIRST set for the i-th symbol in the production.
                                  let symbolFirstSet =
                                      match production.[i] with
                                      | Symbol.Terminal token ->
                                          Set.singleton token
                                      | Symbol.Nonterminal nontermId ->
                                          Map.find nontermId firstSets
  
                                  /// The updated FIRST set for the current nonterminal.
                                  let nontermFirstSet' = Set.union nontermFirstSet symbolFirstSet
  
                                  // Set the 'updated' flag iff the nonterminal's FIRST set
                                  // was actually changed.
  
negative.code:         //
          |> computeNullable
  
      /// Determines if all symbols within the specified slice of a production are nullable.
      let inline private allNullableInSlice (production : Symbol<'NonterminalId, 'Token>[], startInclusive, endInclusive, nullable : Map<'NonterminalId, bool>) =
          let mutable result = true
          let mutable index = startInclusive
          while result && index <= endInclusive do
              result <-
                  match production.[index] with
                  | Symbol.Terminal _ ->
                      false
                  | Symbol.Nonterminal nontermId ->
                      Map.find nontermId nullable
  
              // Increment the index
              index <- index + 1
  
          // Return the result
          result
  
      //
      let internal computeFirst (productions : Map<'NonterminalId, Set<Symbol<'NonterminalId, 'Token>[]>>, nullable : Map<'NonterminalId, bool>) =
          /// Implementation of the algorithm for computing the FIRST sets of the nonterminals.
  