anchor.diff:  
           [<CompiledName("FindIndex")>]
           let findIndex predicate list =
  -            let rec loop n = function[] -> indexNotFound()  | h :: t -> if predicate h then n else loop (n+1) t
  +            let rec loop n list = 
  +                match list with 
  +                | [] -> indexNotFound()
  +                | h :: t -> if predicate h then n else loop (n + 1) t
  +
               loop 0 list
   
           [<CompiledName("TryFindIndex")>]
           let tryFindIndex predicate list =
  -            let rec loop n = function[] -> None | h :: t -> if predicate h then Some n else loop (n+1) t
  +            let rec loop n list = 
  +                match list with
  +                | [] -> None
  +                | h :: t -> if predicate h then Some n else loop (n + 1) t
  +
               loop 0 list
   
           [<CompiledName("FindIndexBack")>]
  
positive.code:         let tryFindIndexBack predicate list = list |> toArray |> Microsoft.FSharp.Primitives.Basics.Array.tryFindIndexBack predicate
  
          [<CompiledName("Sum")>]
          let inline sum          (list:list<'T>) =
              match list with
              | [] ->  LanguagePrimitives.GenericZero< 'T >
              | t ->
                  let mutable acc = LanguagePrimitives.GenericZero< 'T >
                  for x in t do
                      acc <- Checked.(+) acc x
                  acc
  
          [<CompiledName("SumBy")>]
          let inline sumBy (projection: 'T -> 'U)     (list:list<'T>) =
              match list with
              | [] ->  LanguagePrimitives.GenericZero< 'U >
              | t ->
                  let mutable acc = LanguagePrimitives.GenericZero< 'U >
                  for x in t do
                      acc <- Checked.(+) acc (projection x)
                  acc
  
          [<CompiledName("Max")>]
          let inline max          (list:list<_>) =
              match list with
              | [] -> invalidArg "list" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString
              | h :: t ->
  
negative.code:                 exists2aux f list1 list2
  
          [<CompiledName("Find")>]
          let rec find predicate list = 
              match list with
              | [] -> indexNotFound()
              | h :: t -> if predicate h then h else find predicate t
  
          [<CompiledName("TryFind")>]
          let rec tryFind predicate list =
              match list with
              | [] -> None 
              | h :: t -> if predicate h then Some h else tryFind predicate t
  
          [<CompiledName("FindBack")>]
          let findBack predicate list = list |> toArray |> Microsoft.FSharp.Primitives.Basics.Array.findBack predicate
  