anchor.diff:          Transformer = T(fun pos data -> fTransform.Invoke(pos, data) |> box)
       }
   
  +/// <summary>A nonterminal symbol. It is made of <see cref="Production{T}"/>s.</summary>
  +/// <typeparam name="T">The type of the objects this nonterminal generates. All productions of a nonterminal have the same type parameter.</typeparam>
   type Nonterminal<'T> = internal {
       Id: Guid
  -    Name: string
  +    _Name: string
       Productions: SetOnce<Production list>
   }
   with
  +    /// <summary>Creates a <see cref="Nonterminal{T}"/> whose productions can be later set.</summary>
  +    /// <remarks>
  +    ///     <para>If they are not set, it is assumed that the nonterminal consists only of the empty string.</para>
  +    ///     <para>This method exists to help write recursive grammars.</para>
  +    /// </remarks>
  +    /// <param name="name">The nonterminal's name.</param>
       static member Create name = {
           Id = Guid.NewGuid()
  -        Name = name
  +        _Name = name
           Productions = SetOnce<_>.Create()
       }
  +    /// The nonterminal's name.
  +    member x.Name = x._Name
  +    /// <summary>Sets the nonterminal's productions.</summary>
  +    /// <remarks>This method must only be called once. Subsequent calls are ignored.</remarks>
       member x.SetProductions([<ParamArray>] prods: Production<'T> []) =
           prods
           |> Seq.map (fun x -> x :> Production)
           |> List.ofSeq
           |> x.Productions.TrySet
           |> ignore
  +    /// <summary>Creates a <see cref="Nonterminal{T}"/> with the given name and productions.</summary>
  +    static member Create (name, [<ParamArray>] productions) =
  +        let prod = Nonterminal.Create name
  +        prod.SetProductions(productions)
  +        prod
       interface Nonterminal with
           member x.Id = x.Id
  -        // member x.Name = x.Name
           member x.Productions = x.Productions.ValueOrDefault []
       interface DesigntimeFarkle with
  -        member x.Name = x.Name
  +        member x.Name = x._Name
       interface DesigntimeFarkle<'T>
   
  +/// <summary>A production. Productions are parts of <see cref="Nonterminal{T}"/>s.</summary>
  +/// <typeparam name="T">The type of the objects this production generates.</typeparam>
   type Production<'T> = internal {
       Members: Symbol ImmutableArray
       Fuse: obj [] -> obj
  
positive.code: 
  [<Sealed>]
  type ProductionBuilder<'T1, 'T2, 'T3>(members, idx1, idx2, idx3) =
      interface AbstractProductionBuilder<ProductionBuilder<'T1, 'T2, 'T3>> with
          member __.Append(sym) = ProductionBuilder<_, _, _>(Symbol.append members sym, idx1, idx2, idx3)
      member __.Finish(f: 'T1 -> 'T2 -> 'T3 -> 'TOutput) : Production<'TOutput> = {
          Members = members.ToImmutableArray()
          Fuse = fun arr -> f (arr.[idx1] :?> _) (arr.[idx2] :?> _) (arr.[idx3] :?> _) |> box
      }
  
  module Production =
  
      [<CompiledName("Empty")>]
      let empty = ProductionBuilder(ImmutableList.Empty)
  
      [<CompiledName("Append")>]
      let (!%) df =
          df
          |> Symbol.specialize
          |> ImmutableList.Empty.Add
          |> ProductionBuilder
  
      [<CompiledName("Extend")>]
      let (!@) (df: DesigntimeFarkle<'T>) = empty.Extend(df)
  
  module DesigntimeFarkleOperators =
  
      let (||=) name parts =
          let nont = Nonterminal.Create name
          nont.SetProductions(Array.ofSeq parts)
          nont
  
      let inline (@=>) (pb: ^TBuilder when ^TBuilder : (member Finish : ^TFunction -> Production<_>)) f =
          (^TBuilder : (member Finish: ^TFunction -> Production<_>) (pb, f))
  
      let inline (@=%) (pb: ProductionBuilder) (x: 'T) = pb.Finish(x)
  
      // https://github.com/ionide/ionide-vscode-fsharp/issues/1203
      let inline op_DotGreaterGreater (pb: #AbstractProductionBuilder<_>) df = pb.Append df
  
      let inline op_DotGreaterGreaterDot (rb: ^TBuilder when ^TBuilder : (member Extend : DesigntimeFarkle<_> -> ^TBuilderResult)) df =
          (^TBuilder : (member Extend: DesigntimeFarkle<_> -> ^TBuilderResult) (rb, df))
  
negative.code:     Transformer: T<obj> 
  }
  with
      /// The terminal's name.
      member x.Name = x._Name
      interface Terminal with
          member x.Id = x.Id
          member x.Regex = x.Regex
          member x.Transformer = x.Transformer
      interface DesigntimeFarkle with
          member x.Name = x._Name
      interface DesigntimeFarkle<'T>
  
  /// Functions to create `Terminal`s.
  module Terminal =
  
      [<CompiledName("Create")>]
      /// <summary>Creates a <see cref="Terminal{T}"/>.</summary>
      /// <param name="name">The terminal's name.</param>
      /// <param name="fTransform">The function that transforms the terminal's position and data to <c>T</c>.</param>
      /// <param name="regex">The terminal's corresponding regular expression.</param>
      let create name (fTransform: T<'T>) regex: Terminal<'T> = {
          Id = Guid.NewGuid()
          _Name = name
  