anchor.diff:      let inline traverse (f: 'T->'``Functor<'U>``) (s: NonEmptyList<'T>) =
           let lst = traverse f (toList s) : '``Functor<'List<'U>>``
           (create << List.head |> fun f x -> f x (List.tail x)) <!> lst : '``Functor<NonEmptyList<'U>>``
  -         
  +
  +    /// <summary>Returns the average of the elements in the list.</summary>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The resulting average.</returns>
  +    let inline average (list: NonEmptyList<'T>) = List.average (list.Head :: list.Tail)
  +
  +    /// <summary>Returns the average of the elements generated by applying the function to each element of the list.</summary>
  +    /// <param name="projection">The function to transform the list elements into the type to be averaged.</param>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The resulting average.</returns>
  +    let inline averageBy (projection: 'T -> ^U) list = List.averageBy projection (list.Head :: list.Tail)
  +
  +    /// <summary>Applies a function to each element of the list, threading an accumulator argument
  +    /// through the computation. Apply the function to the first two elements of the list.
  +    /// Then feed this result into the function along with the third element and so on. 
  +    /// Return the final result. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes 
  +    /// <c>f (... (f i0 i1) i2 ...) iN</c>.</summary>
  +    /// <param name="reduction">The function to reduce two list elements to a single element.</param>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The final reduced value.</returns>
  +    let reduce (reduction: 'T -> 'T -> 'T) list = List.reduce reduction (list.Head :: list.Tail)
  +
  +    /// <summary>Applies a function to each element of the list, starting from the end, threading an accumulator argument
  +    /// through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes 
  +    /// <c>f i0 (...(f iN-1 iN))</c>.</summary>
  +    /// <param name="reduction">A function that takes in the next-to-last element of the list and the
  +    /// current accumulated result to produce the next accumulated result.</param>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The final result of the reductions.</returns>
  +    let reduceBack (reduction: 'T -> 'T -> 'T) list = List.reduceBack reduction (list.Head :: list.Tail)
  +
  +    /// <summary>Returns the greatest of all elements of the list, compared via Operators.max.</summary>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The maximum element.</returns>
  +    let max (list: NonEmptyList<'T>) = List.max (list.Head :: list.Tail)
  +
  +    /// <summary>Returns the greatest of all elements of the list, compared via Operators.max on the function result.</summary>
  +    /// <param name="projection">The function to transform the list elements into the type to be compared.</param>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The maximum element.</returns>
  +    let maxBy (projection: 'T -> 'U) list = List.maxBy projection (list.Head :: list.Tail)
  +
  +    /// <summary>Returns the lowest of all elements of the list, compared via Operators.min.</summary>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The minimum value.</returns>
  +    let min (list: NonEmptyList<'T>) = List.min (list.Head :: list.Tail)
  +
  +    /// <summary>Returns the lowest of all elements of the list, compared via Operators.min on the function result</summary>
  +    /// <param name="projection">The function to transform list elements into the type to be compared.</param>
  +    /// <param name="list">The input list.</param>
  +    /// <returns>The minimum value.</returns>
  +    let minBy (projection: 'T -> 'U) list = List.minBy projection (list.Head :: list.Tail)
  +
  +    /// Equivalent to [start..stop] on regular lists.
  +    let inline range (start: 'T) stop = create start (drop 1 [start..stop])
  +
  +    /// Reduces using alternative operator `<|>`.
  +    let inline choice (list: NonEmptyList<'``Alt<'T>``>) = reduce (<|>) list : '``Alt<'T>``
  +
  +    /// Transforms a list to a NonEmptyList, returning an option to signal when the original list was empty.
  +    let tryOfList s =
  +        match s with
  +        | []    -> None
  +        | x::xs -> Some (create x xs)
  +
  +
  +[<RequireQualifiedAccess>]
  +module Unchecked =
  +    /// Transforms a sequence to a NonEmptyList. This functions throws if the sequence is empty.
  +    let toNonEmptyList (source: seq<'T>) =
  +        match Seq.toList source with
  +        | []    -> invalidArg "s" "Sequence is empty"
  +        | x::xs -> NonEmptyList.create x xs
  +      
  +
   type NonEmptyList<'t> with
       [<EditorBrowsable(EditorBrowsableState.Never)>]
       static member Map (x: NonEmptyList<'a>, f: 'a->'b) = NonEmptyList.map f x
       
  +    [<EditorBrowsable(EditorBrowsableState.Never)>]
  +    static member Unzip s = NonEmptyList.unzip s
  +
       [<EditorBrowsable(EditorBrowsableState.Never)>]
       static member Zip (x, y) = NonEmptyList.zip x y
   
  
positive.code:     let toSeq  {Head = x; Tail = xs} = seq { yield x; yield! xs; }
      let map f  {Head = x; Tail = xs} = {Head = f x; Tail = List.map f xs}
  
      /// <summary>Combines the two lists into a list of pairs. The two lists must have equal lengths.</summary>
      /// <param name="list1">The first input list.</param>
      /// <param name="list2">The second input list.</param>
      /// <returns>A single list containing pairs of matching elements from the input lists.</returns>
      let zip (list1: NonEmptyList<'T>) (list2: NonEmptyList<'U>) = {Head = (list1.head, list2.head); Tail = List.zip list1.tail list2.tail}
  
      let cons e {Head = x; Tail = xs} = {Head = e  ; Tail = x::xs}
      let rec tails s =
  
negative.code:     interface System.Collections.IEnumerable with member x.GetEnumerator () = (let {Head = x; Tail = xs} = x in seq (x::xs)).GetEnumerator () :> System.Collections.IEnumerator
      interface IReadOnlyCollection<'t>        with member s.Count = 1 + List.length s.Tail
      interface IReadOnlyList<'t>              with member s.Item with get index = s.Item index
  
      [<System.Obsolete("Use Head instead.")>]
      member this.head = let {Head = a; Tail = _} = this in a
  
      [<System.Obsolete("Use Tail instead.")>]
      member this.tail = let           {Tail = a} = this in a
  
      member this.Item = function 0 -> this.Head | n -> this.Tail.[n-1]
      member this.GetSlice = function
          | None  , None
          | Some 0, None
  