anchor.diff:  
       /// Creates a new `CharSpan` that spans one character more than the given one.
       /// A `CharStream` must also be given to validate its length so that out-of-bounds errors are prevented.
  -    let extendSpanByOne cs (CharSpan (idxStart, idxEnd)) =
  -        match cs.Source with
  -        | StaticBlock sb when idxEnd < uint64 sb.Length -> CharSpan (idxStart, idxEnd + GenericOne)
  -        | StaticBlock _ -> failwith "Trying to extend a character span by one character past its end."
  +    let extendSpanByOne (cs: CharStream) (CharSpan (idxStart, idxEnd)) =
  +        if idxEnd < cs.LengthSoFar then
  +            CharSpan (idxStart, idxEnd + GenericOne)
  +        else
  +            failwith "Trying to extend a character span by one character past these that were already read."
   
       /// Creates a new `CharSpan` from two continuous spans, i.e. that starts at the first's start, and ends at the second's end.
       /// Returns `None` if they were not continuous.
  
positive.code: namespace Farkle.Collections
  
  open Farkle
  open System
  
  /// An continuous range of characters that is
  /// stored by its starting index and length.
  
negative.code:     member x.EndingIndex = match x with | CharSpan (_, x) -> x
      override x.ToString() = sprintf "[%d,%d]" x.StartingIndex x.EndingIndex
  
  /// The internal structure to support `CharStreamSource.DynamicBlock`.
  type private DynamicBlock =
      {
          /// The `TextReader` that powers the stream.
          Reader: TextReader
          /// A temporary buffer of characters that are read from the reader
          /// and are going to be read to be generated.
          mutable Buffer: char[]
          /// The index of the first element in the buffer.
          mutable BufferStartingIndex: uint64
          /// The index of the last element in the buffer.
          /// This field is stored because the buffer is
          /// not always full in cases like an end of input.
          mutable BufferEndingIndex: uint64
      }
  
  /// A representation of a `CharStream`.
  type private CharStreamSource =
      /// A representation of a `CharStream` that stores
      /// the characters in one continuous area of memory.
      /// It is not recommended for large files.
      | StaticBlock of ReadOnlyMemory<char>
      /// A representation of a `CharStream` that lazily
      /// loads input from a `TextReader` when it is needed
      /// and unloads it when it is not.
      | DynamicBlock of DynamicBlock
      /// Gets a specified character by index; if it exists in memory, or raises an exception.
      member x.Item
          with get idx =
              match x with
              | StaticBlock sb -> sb.Span.[int idx]
              | DynamicBlock db ->
                  let position = int <| idx - db.BufferStartingIndex
                  if position > 0 && position < db.Buffer.Length then
                      db.Buffer.[position]
                  else
                      failwithf "Trying to get character #%d, while only characters from #%d to #%d have been loaded"
                          idx db.BufferStartingIndex <| db.BufferStartingIndex + uint64 db.Buffer.Length
      /// [omit]
      member x.LengthSoFar =
          match x with
          | StaticBlock x -> uint64 x.Length
          | DynamicBlock db -> db.BufferEndingIndex + GenericOne
  
  /// A data structure that supports efficient and copy-free access to a read-only sequence of characters.
  /// It is not thread-safe.
  type CharStream = private {
      /// The stream's source.
      Source: CharStreamSource
      /// The index of the first element that _must_ be retained in memory
      /// because it is going to be used to generate a token.
      mutable StartingIndex: uint64
      /// [omit]
      mutable _Position: Position
  }
  with
      /// The stream's current position.
      member x.Position = x._Position
      /// The stream's character at its current position.
      member x.FirstCharacter = x.Source.[x.Position.Index]
      /// Returns the length of the input; or at least the
      /// length of the input that has ever crossed the memory.
      member x.LengthSoFar = x.Source.LengthSoFar
  
  /// A type pointing to a character in a character stream.
  type [<Struct>] CharStreamIndex = private CharStreamIndex of uint64
  with
      /// The zero-based index this object points to, starting from the beginning of the stream.
      member x.Index = match x with CharStreamIndex idx -> idx
  
  /// A .NET delegate that is the interface between the `CharStream` API and the post-processor.
  /// It accepts a generic type (a `Symbol` usually), the `Position` of the symbol, and a
  