anchor.diff:      member __.IsEmpty
           with get () =
               (* by Invariant 1, front = empty implies rear = [] *)
  -            LazyList.isEmpty data.Front
  +            LazyList.isEmpty front
   
       /// The number of elements in the queue.
       member __.GetLength () =
           (* = LazyList.length front + length rear -- by Invariant 2 *)
  -        LazyList.length data.Pending + 2 * List.length data.Rear
  +        LazyList.length pending + 2 * List.length rear
   
       /// take from front of queue
       member __.Dequeue () =
           // Preconditions
  -        if LazyList.isEmpty data.Front then
  -            invalidArg "front" "The queue is empty."
  +        if LazyList.isEmpty front then
  +            invalidOp "The queue is empty."
   
  -        LazyList.head data.Front,
  -        Queue<_>.CreateQueue
  -            { data with
  -                Front = LazyList.tail data.Front; }
  +        LazyList.head front,
  +        Queue<_>.CreateQueue (
  +            LazyList.tail front,
  +            rear,
  +            pending)
   
       /// add to rear of queue
       member __.Enqueue value =
  -        Queue<_>.CreateQueue
  -            { data with
  -                Rear = value :: data.Rear; }
  +        Queue<_>.CreateQueue (
  +            front,
  +            value :: rear,
  +            pending)
   
       /// add to front of queue
       member __.EnqueueFront value =
  -        Queue {
  -            Front = LazyList.cons value data.Front;
  -            Rear = data.Rear;
  -            Pending = LazyList.cons value data.Pending; }
  +        Queue (
  +            LazyList.cons value front,
  +            rear,
  +            LazyList.cons value pending)
   
       //
       member this.ToArray () : 'T[] =
  
positive.code: (*   3. (in the absence of insertf's)                *)
  (*      pending = nthtail (front, length rear)       *)
  //
  type internal QueueData<'T> = {
      Front : LazyList<'T>;
      Rear : 'T list;
      Pending : LazyList<'T>;
  }
  
  //
  type Queue<'T> private (data : QueueData<'T>) =
      //
      static let emptyQueue : Queue<'T> =
          Queue {
              Front = LazyList.empty;
              Rear = [];
              Pending = LazyList.empty; }
  
      //
      static member Empty
  
negative.code:                     Queue<_>.Rotate (LazyList.tail xs, ys, LazyList.cons y rys)
  
      //
      static member private CreateQueue (front, rear, pending) =
          if LazyList.isEmpty pending then
              (* length rear = length front + 1 *)
              let front = Queue<_>.Rotate (front, rear, LazyList.empty)
              Queue (front, [], front)
          else
              Queue (
                  front,
                  rear,
                  LazyList.tail pending)
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  