anchor.diff:  
   [<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)
  +    inherit AbstractProductionBuilder<ProductionBuilder<'T1, 'T2, 'T3>>()
  +    override __.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
       }
   
  +[<AutoOpen>]
  +/// Some helper functions to create production builders.
  +/// This module is also intended to be used from C#.
   module Production =
   
       [<CompiledName("Empty")>]
  +    /// A production builder with no parts.
       let empty = ProductionBuilder(ImmutableList.Empty)
   
       [<CompiledName("Append")>]
  +    /// Creates a production builder with one non-significant `DesigntimeFarkle`.
  +    /// This function is useful to start building a `Production`.
       let (!%) df =
           df
           |> Symbol.specialize
           |> ImmutableList.Empty.Add
           |> ProductionBuilder
   
  +    /// Creates a production builder with one significant `DesigntimeFarkle<'T>`.
  +    /// This function is useful to start building a `Production`.
       [<CompiledName("Extend")>]
       let (!@) (df: DesigntimeFarkle<'T>) = empty.Extend(df)
   
  +[<AutoOpen>]
  +/// F# operators to easily work with productions and their builders.
   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)
  -
  +    /// Creates a `NonTerminal<'T>` with the given name and parts.
  +    let inline (||=) name parts = Nonterminal.Create(name, Array.ofSeq parts)
  +
  +    /// The `Append` method of production builders as an operator.
       // https://github.com/ionide/ionide-vscode-fsharp/issues/1203
       let inline op_DotGreaterGreater (pb: #AbstractProductionBuilder<_>) df = pb.Append df
   
  +    /// The `Extend` method of production builders as an operator.
       let inline op_DotGreaterGreaterDot (rb: ^TBuilder when ^TBuilder : (member Extend : DesigntimeFarkle<_> -> ^TBuilderResult)) df =
           (^TBuilder : (member Extend: DesigntimeFarkle<_> -> ^TBuilderResult) (rb, df))
  +
  +    /// The `Finish` method of production builders as an operator.
  +    let inline (@=>) (pb: ^TBuilder when ^TBuilder : (member Finish : ^TFunction -> Production<'T>)) f =
  +        (^TBuilder : (member Finish: ^TFunction -> Production<'T>) (pb, f))
  +
  +    /// `ProductionBuilder.FinishConstant` as an operator.
  +    let inline (@=%) (pb: ProductionBuilder) (x: 'T) = pb.FinishConstant(x)
  
positive.code: 
  [<Sealed>]
  type ProductionBuilder<'T1, 'T2>(members, idx1, idx2) =
      interface AbstractProductionBuilder<ProductionBuilder<'T1, 'T2>> with
          member __.Append(sym) = ProductionBuilder<_, _>(Symbol.append members sym, idx1, idx2)
      member __.Extend(df: DesigntimeFarkle<'T3>) = ProductionBuilder<'T1, 'T2, 'T3>(ImmutableList.add members (Symbol.specialize df), idx1, idx2, members.Count)
      member __.Finish(f: 'T1 -> 'T2 -> 'TOutput) : Production<'TOutput> = {
          Members = members.ToImmutableArray()
  
negative.code:         | _ -> failwith "Using a custom derivative of the DesigntimeFarkle interface is not allowed."
      let append xs df = ImmutableList.add xs (specialize df)
  
  [<AbstractClass>]
  /// <summary>The base, untyped class of the production builders.</summary>
  /// <remarks>
  ///     <para>A production builder is an object that helps to fluently construct <see cref="Production{T}"/>s
  ///     by aggregating the types of its significant parts. The types of the production's
  ///     significant parts are indicated by the type parameters. For example, a <c>ProductionBuilder</c> has no
  ///     significant parts, and a <c>ProductionBuilder&lt;int, string&gt;</c> has two significant parts; an integer
  ///     and a string.</para>
  ///     <para>Production builders have three basic methods.</para>
  ///     <para><c>Append</c> returns a production builder with the same significant parts,
  ///     but the given <see cref="DesigntimeFarkle"/> at the end of it.</para>
  ///     <para><c>Extend</c> returns a production builder with one more significant part,
  ///     whose type is determined by the given <see cref="DesigntimeFarkle{T}"/> that will
  ///     be appended to it.</para>
  ///     <para><c>Finish</c> accepts a function that converts all the builder's significant parts
  ///     into the eventual type of the returned <see cref="Production{T}"/>.</para>
  /// </remarks>
  /// <typeparam name="T">The type of the concrete production builder. Used so that
  /// <see cref="AbstractProductionBuilder{TBuilder}.Append"/> can return the correct production builder type</typeparam>
  type AbstractProductionBuilder<'TBuilder>() =
      /// <seealso cref="AbstractProductionBuilder{TBuilder}"/>
      abstract Append: DesigntimeFarkle -> 'TBuilder
  
  [<Sealed>]
  type ProductionBuilder(members) =
      inherit AbstractProductionBuilder<ProductionBuilder>()
      override __.Append(sym) = ProductionBuilder(Symbol.append members sym)
      member __.Extend(df: DesigntimeFarkle<'T1>) = ProductionBuilder<'T1>(ImmutableList.add members (Symbol.specialize df), members.Count)
      member x.Finish(fFuseThunk) = x.FinishRaw(fun _ -> fFuseThunk ())
      /// <summary>Like <c>Finish</c>, but the given function accepts
      /// an array of all the production's parts as objects.</summary>
      /// <remarks>
      ///     <para>This method is intended to be used when finishing a production with many significant parts.</para>
      ///     <para>Do not rely on the array's length; it can be larger than the number of parts of the production.</para>
      /// </remarks>
      member __.FinishRaw(fFuseRaw: _ -> 'TOutput) : Production<'TOutput> = {
          Members = members.ToImmutableArray()
          Fuse = fFuseRaw >> box
      }
      /// <summary>Creates a <see cref="Production{T}"/> that always returns a constant value.</summary>
      member x.FinishConstant(v) = x.FinishRaw(fun _ -> v)
  
  [<Sealed>]
  type ProductionBuilder<'T1>(members, idx1) =
      inherit AbstractProductionBuilder<ProductionBuilder<'T1>>()
      override __.Append(sym) = ProductionBuilder<_>(Symbol.append members sym, idx1)
      member __.Extend(df: DesigntimeFarkle<'T2>) = ProductionBuilder<'T1, 'T2>(ImmutableList.add members (Symbol.specialize df), idx1, members.Count)
      member __.Finish(f: 'T1 -> 'TOutput) : Production<'TOutput> = {
          Members = members.ToImmutableArray()
  