anchor.diff:                  LazyList.cons y rys
               else
                   LazyList.consDelayed (LazyList.head xs) <| fun () ->
  -                    rotate (LazyList.tail xs, ys, LazyList.cons y rys)
  +                    Queue<_>.Rotate (LazyList.tail xs, ys, LazyList.cons y rys)
   
  -    (* Psuedo-constructor that enforces invariant *)
  -    (*   always called with length pending = length front - length rear + 1 *)
  -    let private queue { Front = front; Rear = rear; Pending = pending; } =
  +    //
  +    static member private CreateQueue { Front = front; Rear = rear; Pending = pending; } =
           if LazyList.isEmpty pending then
               (* length rear = length front + 1 *)
  -            let front = rotate (front, rear, LazyList.empty)
  +            let front = Queue<_>.Rotate (front, rear, LazyList.empty)
               Queue {
                   Front = front;
                   Rear = [];
  
positive.code: open ExtCore
  
  
  //
  type QueueData<'T> = {
      Front : LazyList<'T>;
      Rear : 'T list;
      Pending : LazyList<'T>;
  }
  
  //
  type Queue<'T> = Queue of QueueData<'T>
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Queue =
      (* INVARIANTS                                        *)
      (*   1. length front >= length rear                  *)
      (*   2. length pending = length front - length rear  *)
      (*   3. (in the absence of insertf's)                *)
      (*      pending = nthtail (front, length rear)       *)
  
      //
      let rec private rotate (xs, ys, rys) =
          match ys with
          | [] ->
              // This should never happen -- it's only here to satisfy
  
negative.code:                 Rear = rear;
                  Pending = LazyList.tail pending; }
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Queue =
      /// Returns an empty queue of the given type.
      [<CompiledName("Empty")>]
      [<GeneralizableValue>]
      let empty<'T> : Queue<'T> =
          Queue<'T>.Empty
  
      /// Returns true if the given queue is empty; otherwise, false.
      let inline isEmpty (queue : Queue<'T>) =
          // Preconditions
          checkNonNull "queue" queue
  
          queue.IsEmpty
  
      /// The number of elements in the queue.
      let inline size (queue : Queue<'T>) =
          // Preconditions
          checkNonNull "queue" queue
  
          queue.GetLength ()
  
      /// add to rear of queue
      let inline enqueue value (queue : Queue<'T>) =
          // Preconditions
          checkNonNull "queue" queue
  
          queue.Enqueue value
  
      /// add to front of queue
      let inline enqueuef value (queue : Queue<'T>) =
          // Preconditions
          checkNonNull "queue" queue
  
          queue.EnqueueFront value
  
      /// take from front of queue
      let inline dequeue (queue : Queue<'T>) =
          // Preconditions
          checkNonNull "queue" queue
  
          queue.Dequeue ()
  
      //
      let inline toArray (queue : Queue<'T>) : 'T[] =
          // Preconditions
          checkNonNull "queue" queue
          
          queue.ToArray ()
  
  