anchor.diff:  
   [<TestCase>]
   let ``LALR(1) table for Grammar 3.26`` () =
  +    let expectedActionTable =
  +        Map.empty
  +        |> Table.term 1 "*" (Action <| Shift 1<_>)
  +        |> Table.term 1 "x" (Action <| Shift 8<_>)
  +
  +        |> Table.term 2 "*" (Action <| Shift 1<_>)
  +        |> Table.term 2 "x" (Action <| Shift 8<_>)
  +
  +        |> Table.term 3 "*" (Action <| Shift 1<_>)
  +        |> Table.term 3 "x" (Action <| Shift 8<_>)
  +
  +        |> Table.term 4 "=" (Action <| Reduce 1<_>)
  +        |> Table.eof 4 (Action <| Reduce 1<_>)
  +
  +        |> Table.term 5 "=" (Action <| Shift 3<_>)
  +        |> Table.eof 5 (Action <| Reduce 1<_>)
  +
  +        |> Table.eof 6 (Action <| Reduce 2<_>)
  +
  +        |> Table.eof 7 (Action <| Reduce 5<_>)
  +
  +        |> Table.term 8 "=" (Action <| Reduce 3<_>)
  +        |> Table.eof 8 (Action <| Reduce 3<_>)
  +
  +        |> Table.term 9 "=" (Action <| Reduce 4<_>)
  +        |> Table.eof 9 (Action <| Reduce 4<_>)
  +
  +        |> Table.eof 10 (Action Accept)
  +
  +    let expectedGotoTable =
  +        Map.empty
  +        |> Table.nterm 1 'E' 9
  +        |> Table.nterm 1 'V' 4
  +
  +        |> Table.nterm 2 'E' 6
  +        |> Table.nterm 2 'S' 10
  +        |> Table.nterm 2 'V' 5
  +
  +        |> Table.nterm 3 'E' 7
  +        |> Table.nterm 3 'V' 4
  +
       let lr0ParserTable = Lr0.createTable Appel.``Grammar 3.26``
   
       let lalr1ParserTable =
  
positive.code: 
  [<TestCase>]
  let ``SLR table for Grammar 3.23`` () =
      let lr0ParserTable = Lr0.createTable Appel.``Grammar 3.23``
  
      let slr1ParserTable =
          let productionRuleIds = Grammar.ProductionRuleIds Appel.``Grammar 3.23``
          Slr1.upgrade (Appel.``Grammar 3.23``, lr0ParserTable, productionRuleIds)
  
      let expectedActionTable =
          Map.empty
          |> Map.add (1<ParserStateIdentifier>, AugmentedTerminal.Terminal "x") (Action <| Shift 3<_>)
  
          |> Map.add (2<ParserStateIdentifier>, AugmentedTerminal.Terminal "+") (Action <| Shift 5<_>)
          |> Map.add (2<ParserStateIdentifier>, AugmentedTerminal.EndOfFile) (Action <| Reduce 1<_>)
  
          |> Map.add (3<ParserStateIdentifier>, AugmentedTerminal.Terminal "+") (Action <| Reduce 2<_>)
          |> Map.add (3<ParserStateIdentifier>, AugmentedTerminal.EndOfFile) (Action <| Reduce 2<_>)
  
          |> Map.add (4<ParserStateIdentifier>, AugmentedTerminal.EndOfFile) (Action Accept)
  
          |> Map.add (5<ParserStateIdentifier>, AugmentedTerminal.Terminal "x") (Action <| Shift 3<_>)
  
          |> Map.add (6<ParserStateIdentifier>, AugmentedTerminal.EndOfFile) (Action <| Reduce 3<_>)
  
      let expectedGotoTable =
          Map.empty
          |> Map.add (1<ParserStateIdentifier>, AugmentedNonterminal.Nonterminal 'E') 4<_>
          |> Map.add (1<ParserStateIdentifier>, AugmentedNonterminal.Nonterminal 'T') 2<_>
          |> Map.add (5<ParserStateIdentifier>, AugmentedNonterminal.Nonterminal 'E') 6<_>
          |> Map.add (5<ParserStateIdentifier>, AugmentedNonterminal.Nonterminal 'T') 2<_>
  
      // Verify the ACTION table.
      slr1ParserTable.ActionTable
      |> should equal expectedActionTable
  
negative.code:         | Choice1Of2 lookaheadSets ->
              Lalr1.upgrade (Appel.``Grammar 3.26``, lr0ParserTable, productionRuleIds, lookaheadSets)
  
      // Verify the ACTION table.
      lalr1ParserTable.ActionTable
      |> should equal expectedActionTable
  