anchor.diff:          | _ -> failwith "Using a custom derivative of the DesigntimeFarkle interface is not allowed."
       let append xs df = ImmutableList.add xs (specialize df)
   
  -type AbstractProductionBuilder<'T> =
  -    abstract Append: DesigntimeFarkle -> 'T
  +[<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) =
  -    interface AbstractProductionBuilder<ProductionBuilder> with
  -        member __.Append(sym) = ProductionBuilder(Symbol.append members sym)
  +    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
       }
  -    member x.Finish(fFuseThunk) = x.FinishRaw(fun _ -> fFuseThunk ())
  -    member x.Finish(fConstant) = x.FinishRaw(fun _ -> fConstant)
  +    /// <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) =
  -    interface AbstractProductionBuilder<ProductionBuilder<'T1>> with
  -        member __.Append(sym) = ProductionBuilder<_>(Symbol.append members sym, 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()
  
positive.code:         Transformer = T(fun pos data -> fTransform.Invoke(pos, data) |> box)
      }
  
  type Nonterminal<'T> = internal {
      Id: Guid
      Name: string
      Productions: SetOnce<Production list>
  }
  with
      static member Create name = {
          Id = Guid.NewGuid()
          Name = name
          Productions = SetOnce<_>.Create()
      }
      member x.SetProductions([<ParamArray>] prods: Production<'T> []) =
          prods
          |> Seq.map (fun x -> x :> Production)
          |> List.ofSeq
          |> x.Productions.TrySet
          |> ignore
      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
      interface DesigntimeFarkle<'T>
  
  type Production<'T> = internal {
      Members: Symbol ImmutableArray
      Fuse: obj [] -> obj
  
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
  