anchor.diff:     foldIndexed2 (fun _ acc x y -> f acc x y) seed xs ys
   
   let foldBack2<'a, 'b, 'acc> f (xs: 'a list) (ys: 'b list) (seed:'acc) =
  -   fold2 f seed (reverse xs) (reverse ys)
  +   fold2 (fun acc x y -> f x y acc) seed (reverse xs) (reverse ys)
   
   let rec foldIndexed3Aux f i acc bs cs ds =
      match bs, cs, ds with
  
positive.code: let partition f xs =
     fold (fun (lacc, racc) x ->
        if f x then x::lacc, racc
        else lacc,x::racc) ([],[]) xs
  
  let choose f xs =
     fold (fun acc x ->
  
negative.code:    |> ofArray
  
  // TODO: Is there a more efficient algorithm?
  let rec takeAux error i acc xs =
      match i, xs with
      | 0, _ -> reverse acc
      | _, [] ->
        if error then
            failwith "The input sequence has an insufficient number of elements."
        else
            reverse acc
      | _, x::xs -> takeAux error (i - 1) (x::acc) xs
  let take i xs =
    match i, xs with
    | i, _ when i < 0 -> failwith "The input must be non-negative."
    | 0, _ -> []
    | 1, x::_ -> [x]
    | i, xs -> takeAux true i [] xs
  
  let truncate i xs =
    match i, xs with
    | i, _ when i < 0 -> failwith "The input must be non-negative."
    | 0, _ -> []
    | 1, x::_ -> [x]
    | i, xs -> takeAux false i [] xs
  
  let skip i xs =
    let rec skipInner i xs =
  