anchor.diff:              (ListZipper (path, prev :: list)).ToList ()
   
   
  -/// Functional operators related to the ListZipper<_> type.
  +/// <summary>Functional operators related to the <see cref="ListZipper`1"/> type.</summary>
   [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module ListZipper =
       /// The empty zipper value.
  
positive.code:             | current :: _ ->
                  Some current
  
      /// The previous element (if any).
      member __.Previous
          with get () =
              match path with
  
negative.code:             | prev :: _ ->
                  Some prev
  
      /// <summary>Moves the zipper backwards by one step.</summary>
      /// <returns></returns>
      /// <remarks>No exception is raised if the zipper is already at the start of the list.</remarks>
      member this.MoveBack () =
          match path with
          | [] -> this
          | prev :: path ->
              ListZipper (path, prev :: list)
  
      /// <summary>Moves the zipper forwards by one step.</summary>
      /// <returns></returns>
      /// <remarks>No exception is raised if the zipper is already at the end of the list.</remarks>
      member this.MoveNext () =
          match list with
          | [] -> this
          | current :: list ->
              ListZipper (current :: path, list)
  
      /// <summary>Moves the zipper to the start of the list.</summary>
      /// <returns></returns>
      /// <remarks>No exception is raised if the zipper is already at the start of the list.</remarks>
      member this.MoveStart () =
          match path with
          | [] -> this
          | prev :: path ->
              (ListZipper (path, prev :: list)).MoveStart ()
  
      /// <summary>Moves the zipper to the end of the list.</summary>
      /// <returns></returns>
      /// <remarks>No exception is raised if the zipper is already at the end of the list.</remarks>
      member this.MoveEnd () =
          match list with
          | [] -> this
          | current :: list ->
              (ListZipper (current :: path, list)).MoveEnd ()
  
      /// <summary>Creates a new zipper by removing the current element from the list.</summary>
      /// <returns></returns>
      /// <remarks>No exception is raised if the zipper is empty.</remarks>
      member this.Remove () =
          match list with
          | [] -> this
          | _ :: list ->
              ListZipper (path, list)
  
      /// <summary>
      /// Creates a new zipper by inserting the given value prior to the current list element.
      /// If the zipper is empty, the new zipper's list is created from the given value.
      /// </summary>
      /// <param name="value"></param>
      /// <returns></returns>
      member this.Insert (value : 'T) =
          ListZipper (path, value :: list)
  
      /// <summary>Creates a new zipper by replacing the current list element with the given value.</summary>
      /// <param name="value"></param>
      /// <returns></returns>
      /// <remarks>
      /// This is similar to <c>zipper.Remove().Insert(value)</c> except that when the zipper
      /// is empty, <c>zipper.Update(value)</c> returns an empty zipper.
      /// </remarks>
      member this.Update (value : 'T) =
          match list with
          | [] -> this
          | _ :: list ->
              ListZipper (path, value :: list)
  
      /// <summary>
      /// Returns a new list whose elements are the same as those in the zipper, and also in the same order as those in the zipper.
      /// </summary>
      /// <returns></returns>
      member __.ToList () : 'T list =
          // Same as ListZipper.MoveStart(), except here we return the list
          // once we've reached the start of the list.
  