anchor.diff:      | x::xs, y::ys -> foldIndexed2Aux f (i+1) (f i acc x y) xs ys
       | _ -> invalidOp "Lists had different lengths"
   
  -let foldIndexed2<'a, 'b, 'acc> f (seed:'acc) (xs: 'a list) (ys: 'b list) =
  -    foldIndexed2Aux f 0 seed xs ys
  -
  -let fold2<'a, 'b, 'acc> f (seed:'acc) (xs: 'a list) (ys: 'b list) =
  -    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 foldIndexed2<'a, 'b, 'acc> f (state: 'acc) (xs: 'a list) (ys: 'b list) =
  +    foldIndexed2Aux f 0 state xs ys
  +
  +let fold2<'a, 'b, 'acc> f (state: 'acc) (xs: 'a list) (ys: 'b list) =
  +    Seq.fold2 f state xs ys
  +
  +let foldBack2<'a, 'b, 'acc> f (xs: 'a list) (ys: 'b list) (state: 'acc) =
  +    Seq.foldBack2 f xs ys state
   
   let unfold f state =
       let rec unfoldInner acc state =
           match f state with
  -        |None -> reverse acc
  -        |Some (x,state) -> unfoldInner (x::acc) state
  +        | None -> reverse acc
  +        | Some (x,state) -> unfoldInner (x::acc) state
       unfoldInner [] state
   
   let rec foldIndexed3Aux f i acc bs cs ds =
  
positive.code: let foldIndexed3<'a, 'b, 'c, 'acc> f (seed:'acc) (xs: 'a list) (ys: 'b list) (zs: 'c list) =
      foldIndexed3Aux f 0 seed xs ys zs
  
  let fold3<'a, 'b, 'c, 'acc> f (seed:'acc) (xs: 'a list) (ys: 'b list) (zs: 'c list) =
      foldIndexed3 (fun _ acc x y z -> f acc x y z) seed xs ys zs
  
  let scan<'a, 'acc> f (seed:'acc) (xs: 'a list) =
      fold (fun acc x ->
          match acc with
          | [] -> failwith "never"
          | y::_ -> f y x::acc) [seed] xs
      |> reverse
  
  let scanBack<'a, 'acc> f (xs: 'a list) (seed:'acc) =
      scan (fun acc x -> f x acc) seed (reverse xs)
      |> reverse
  
  let length xs =
      fold (fun acc _ -> acc + 1) 0 xs
  
negative.code: let append xs ys =
      fold (fun acc x -> x::acc) ys (reverse xs)
  
  let collect f (xs: 'a list) =
      Seq.collect f xs |> ofSeq
  
  let map f xs =
      fold (fun acc x -> f x::acc) [] xs
      |> reverse
  
  let mapIndexed f xs =
  