anchor.diff:  let partition f xs =
      fold (fun (lacc, racc) x ->
         if f x then x::lacc, racc
  -      else lacc,x::racc) ([],[]) xs
  +      else lacc,x::racc) ([],[]) (reverse xs)
   
   let choose f xs =
      fold (fun acc x ->
  
positive.code:    |> ofArray
  
  // TODO: Is there a more efficient algorithm?
  let take i xs =
    let rec takeInner i acc xs =
        match i, xs with
        | 0, _ -> reverse acc
        | _, [] -> failwith "The input sequence has an insufficient number of elements."
        | _, x::xs -> takeInner (i - 1) (x::acc) xs
    match i, xs with
    | i, _ when i < 0 -> failwith "The input must be non-negative."
    | 0, _ -> []
    | 1, x::_ -> [x]
    | i, xs -> takeInner i [] xs
  
  let skip i xs =
    let rec skipInner i xs =
  
negative.code:    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 (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
  