anchor.diff:                      // Pass 'lookback' and 'includes' through to the next iteration.
                       lookback, includes))
   
  -    //
  +    (*  TODO :  Modify the 'lookaheadSets' function to accept another parameter specifying the
  +                ambiguous LR(0) states (i.e., the states which need the LA sets in order to
  +                resolve their conflicts). By only computing the LA sets which are actually needed,
  +                the number of set-union operations is greatly reduced -- leading to improved
  +                average-case performance. This optimization can be further leveraged by upgrading
  +                the LR(0) parser table to SLR(1) before upgrading to LALR(1); the upgrade to
  +                SLR(1) will resolve many/most conflicts so we'll only need to compute LA sets
  +                for the remaining states. *)
  +
  +    /// Computes the LALR(1) look-ahead (LA) sets given a grammar and its LR(0) parser table.
       let private lookaheadSets (grammar : AugmentedGrammar<'Nonterminal, 'Terminal>, lr0ParserTable : Lr0ParserTable<'Nonterminal, 'Terminal>)
           : Choice<Map<_,_>, string> =
           (* DeRemer and Penello's algorithm for computing LALR look-ahead sets. *)
  
positive.code:             #if DEBUG
              let untraversed =
                  X |> Set.filter (fun x ->
                      match Map.find x N with Traversed -> false | _ -> true)
              Debug.Assert (
                  Set.isEmpty untraversed,
                  sprintf "There are %i elements of X (Count = %i) which have not been completely traversed." (Set.count untraversed) (Set.count X))
  
negative.code:                 ||> Set.fold (fun (F, N, stack) y ->
                      let F, N, stack =
                          match Map.find y N with
                          | NotStarted ->
                              traverse (y, N, stack, F, X, R, F')
                          | _ ->
                              F, N, stack
  