anchor.diff:  
       [<CompiledName("ToFSharpList")>]
       [<Extension>]
  -    let inline toList (x: NonEmptyList<_>) = x.Head :: x.Tail
  +    let toList (x: NonEmptyList<_>) = x.List
   
       [<CompiledName("Length")>]
       let inline length (x: NonEmptyList<_>) = x.Length
  
positive.code: open System.Collections.Generic
  open System.Runtime.CompilerServices
  open FSharpx
  
  type NonEmptyList<'T> = 
      { Head: 'T
        Tail: 'T list }
  
      member x.Length = x.Tail.Length + 1
  
      interface IEnumerable<'T> with
          member x.GetEnumerator() = 
              let e = seq {
                  yield x.Head
                  yield! x.Tail }
              e.GetEnumerator()
      interface System.Collections.IEnumerable with
          member x.GetEnumerator() = (x :> _ seq).GetEnumerator() :> IEnumerator
  
  [<Extension>]
  module NonEmptyList =
      [<CompiledName("Create")>]
      let inline create head tail = { Head = head; Tail = tail }
  
      [<CompiledName("Create")>]
      let inline createParamsArray(head, [<ParamArray>] tail) = { Head = head; Tail = Array.toList tail }
  
      [<CompiledName("Singleton")>]
      let inline singleton value = create value []
  
negative.code:     [<CompiledName("ToArray")>]
      [<Extension>]
      let toArray list =
           Array.ofList list.List
  
      [<CompiledName("AsEnumerable")>]
      [<Extension>]
      let inline toSeq (list: NonEmptyList<_>) = list :> _ seq
  
      [<CompiledName("OfArray")>]
      let ofArray (arr: _ array) =
          match arr.Length with
          | 0 -> invalidArg "arr" "Array is empty"
          | _ -> { List = List.ofArray arr }
  
      [<CompiledName("OfList")>]
      let ofList (l: _ list) =
          match l with
          | head :: tail -> create head tail
          | _ -> invalidArg "l" "List is empty"
  
      [<CompiledName("OfSeq")>]
      let ofSeq (e: _ seq) =
          if Seq.isEmpty e then
              invalidArg "e" "Sequence is empty"
          else
              {List = List.ofSeq e}
  
      [<CompiledName("Select")>]
      let map f list =
          { List = List.map f list.List }
  
      [<CompiledName("Cons")>]
      let cons head tail =
          { List = head :: tail.List }
  
      [<CompiledName("Concat")>]
      let appendList list1 list2 =
          { List = list1.List @ list2 }
              
      [<CompiledName("Concat")>]
      let append list1 list2 =
          { List = list1.List @ list2.List }
  
      [<CompiledName("Aggregate")>]
      let reduce reduction list =
          List.reduce reduction list.List
  
      [<CompiledName("Last")>]
      let last list =
          List.last list.List
  
      [<CompiledName("Reverse")>]
      [<Extension>]
      let rev list =
          { List = List.rev list.List}
  
      [<CompiledName("SelectMany")>]
      let collect mapping list =
          List.fold (fun s e -> mapping e |> append s) (mapping (head list)) (tail list)
  
      [<CompiledName("Zip")>]
      let zip list1 list2 =
          { List = List.zip list1.List list2.List }