anchor.diff:      results1, results2
   
   //
  -[<CompiledName("Partition")>]
  -let partition predicate (resizeArray : ResizeArray<'T>) : ResizeArray<'T> * ResizeArray<'T> =
  -    // Preconditions
  -    checkNonNull "resizeArray" resizeArray
  -
  -    let trueResults = ResizeArray ()
  -    let falseResults = ResizeArray ()
  -
  -    let len = length resizeArray
  -    for i = 0 to len - 1 do
  -        let el = resizeArray.[i]
  -        if predicate el then
  -            trueResults.Add el
  -        else
  -            falseResults.Add el
  -
  -    trueResults, falseResults
  -
  -//
  -[<CompiledName("Fold2")>]
  -let fold2 folder (state : 'State)
  -    (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : 'State =
  +[<CompiledName("Exists")>]
  +let inline exists (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : bool =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    resizeArray.Exists (System.Predicate predicate)
  +
  +//
  +[<CompiledName("Exists2")>]
  +let exists2 predicate (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : bool =
       // Preconditions
       checkNonNull "resizeArray1" resizeArray1
       checkNonNull "resizeArray2" resizeArray2
   
       let len = length resizeArray1
       if len <> length resizeArray2 then
  -        invalidArg "resizeArray2" "The arrays have different lengths."
  -
  -    let folder = FSharpFunc<_,_,_,_>.Adapt folder
  -    let mutable state = state
  -    for i = 0 to len - 1 do
  -        state <- folder.Invoke (state, resizeArray1.[i], resizeArray2.[i])
  -    state
  -
  -//
  -[<CompiledName("FoldBack2")>]
  -let foldBack2 folder (resizeArray1 : ResizeArray<'T1>)
  -    (resizeArray2 : ResizeArray<'T2>) (state : 'State) : 'State =
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let predicate = FSharpFunc<_,_,_>.Adapt predicate
  +    
  +    let mutable index = 0
  +    let mutable foundMatch = false
  +    while index < len && not foundMatch do
  +        foundMatch <- predicate.Invoke (resizeArray1.[index], resizeArray2.[index])
  +        index <- index + 1
  +    foundMatch
  +
  +//
  +[<CompiledName("Forall")>]
  +let inline forall (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : bool =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    resizeArray.TrueForAll (System.Predicate predicate)
  +
  +//
  +[<CompiledName("Forall2")>]
  +let forall2 predicate (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : bool =
       // Preconditions
       checkNonNull "resizeArray1" resizeArray1
       checkNonNull "resizeArray2" resizeArray2
   
       let len = length resizeArray1
       if len <> length resizeArray2 then
  -        invalidArg "resizeArray2" "The arrays have different lengths."
  -
  -    let folder = FSharpFunc<_,_,_,_>.Adapt folder
  -    let mutable state = state
  -    for i = len - 1 downto 0 do
  -        state <- folder.Invoke (resizeArray1.[i], resizeArray2.[i], state)
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let predicate = FSharpFunc<_,_,_>.Adapt predicate
  +    
  +    let mutable index = 0
  +    let mutable allMatch = true
  +    while index < len && allMatch do
  +        allMatch <- predicate.Invoke (resizeArray1.[index], resizeArray2.[index])
  +        index <- index + 1
  +    allMatch
  +
  +//
  +[<CompiledName("Filter")>]
  +let inline filter (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : ResizeArray<'T> =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    resizeArray.FindAll (System.Predicate predicate)
  +
  +//
  +[<CompiledName("Choose")>]
  +let choose (chooser : 'T -> 'U option) (resizeArray : ResizeArray<'T>) : ResizeArray<'U> =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    // OPTIMIZATION : If the input list is empty return immediately.
  +    if isEmpty resizeArray then
  +        ResizeArray ()
  +    else
  +        let result = ResizeArray ()
  +        let count = resizeArray.Count
  +
  +        for i = 0 to count - 1 do
  +            match chooser resizeArray.[i] with
  +            | None -> ()
  +            | Some value ->
  +                result.Add value
  +
  +        result
  +
  +//
  +[<CompiledName("TryFind")>]
  +let tryFind (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : 'T option =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    match resizeArray.FindIndex (System.Predicate predicate) with
  +    | -1 ->
  +        None
  +    | index ->
  +        Some resizeArray.[index]
  +
  +//
  +[<CompiledName("Find")>]
  +let find (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : 'T =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    match resizeArray.FindIndex (System.Predicate predicate) with
  +    | -1 ->
  +        // TODO : Add a better error message.
  +        // keyNotFound ""
  +        raise <| System.Collections.Generic.KeyNotFoundException ()
  +    | index ->
  +        resizeArray.[index]
  +
  +//
  +[<CompiledName("TryFindIndex")>]
  +let tryFindIndex (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : int option =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    match resizeArray.FindIndex (System.Predicate predicate) with
  +    | -1 ->
  +        None
  +    | index ->
  +        Some index
  +        
  +//
  +[<CompiledName("FindIndex")>]
  +let findIndex (predicate : 'T -> bool) (resizeArray : ResizeArray<'T>) : int =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    match resizeArray.FindIndex (System.Predicate predicate) with
  +    | -1 ->
  +        // TODO : Add a better error message.
  +        // keyNotFound ""
  +        raise <| System.Collections.Generic.KeyNotFoundException ()
  +    | index ->
  +        index
  +
  +//
  +[<CompiledName("TryFindIndexIndexed")>]
  +let tryFindIndexi predicate (resizeArray : ResizeArray<'T>) : int option =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let predicate = FSharpFunc<_,_,_>.Adapt predicate
  +
  +    let lastIndex = length resizeArray - 1
  +    let mutable index = -1
  +    let mutable foundMatch = false
  +    while index < lastIndex && not foundMatch do
  +        let i = index + 1
  +        index <- i
  +        foundMatch <- predicate.Invoke (i, resizeArray.[i])
  +
  +    if foundMatch then
  +        Some index
  +    else None
  +
  +//
  +[<CompiledName("FindIndexIndexed")>]
  +let findIndexi predicate (resizeArray : ResizeArray<'T>) : int =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    match tryFindIndexi predicate resizeArray with
  +    | Some index ->
  +        index
  +    | None ->
  +        keyNotFound "An element satisfying the predicate was not found in the collection."
  +
  +//
  +[<CompiledName("TryPick")>]
  +let tryPick (picker : 'T -> 'U option) (resizeArray : ResizeArray<'T>) : 'U option =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let count = resizeArray.Count
  +    let mutable result = None
  +    let mutable index = 0
  +
  +    while index < count && Option.isNone result do
  +        result <- picker resizeArray.[index]
  +        index <- index + 1
  +    result
  +
  +//
  +[<CompiledName("Pick")>]
  +let pick (picker : 'T -> 'U option) (resizeArray : ResizeArray<'T>) : 'U =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let count = resizeArray.Count
  +    let mutable result = None
  +    let mutable index = 0
  +
  +    while index < count && Option.isNone result do
  +        result <- picker resizeArray.[index]
  +        index <- index + 1
  +
  +    match result with
  +    | Some result ->
  +        result
  +    | None ->
  +        // TODO : Return a better error message
  +        //keyNotFound ""
  +        raise <| System.Collections.Generic.KeyNotFoundException ()
  +
  +//
  +[<CompiledName("Iter")>]
  +let iter (action : 'T -> unit) (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let count = resizeArray.Count
  +    for i = 0 to count - 1 do
  +        action resizeArray.[i]
  +
  +//
  +[<CompiledName("IterIndexed")>]
  +let iteri (action : int -> 'T -> unit) (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let action = FSharpFunc<_,_,_>.Adapt action
  +
  +    let count = resizeArray.Count
  +    for i = 0 to count - 1 do
  +        action.Invoke (i, resizeArray.[i])
  +
  +//
  +[<CompiledName("Iter2")>]
  +let iter2 action (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T1>) : unit =
  +    // Preconditions
  +    checkNonNull "resizeArray1" resizeArray1
  +    checkNonNull "resizeArray2" resizeArray2
  +
  +    let len = length resizeArray1
  +    if len <> length resizeArray2 then
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let action = FSharpFunc<_,_,_>.Adapt action
  +
  +    for i = 0 to len - 1 do
  +        action.Invoke (resizeArray1.[i], resizeArray2.[i])
  +
  +//
  +[<CompiledName("IterIndexed2")>]
  +let iteri2 action (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : unit =
  +    // Preconditions
  +    checkNonNull "resizeArray1" resizeArray1
  +    checkNonNull "resizeArray2" resizeArray2
  +
  +    let len = length resizeArray1
  +    if len <> length resizeArray2 then
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let action = FSharpFunc<_,_,_,_>.Adapt action
  +
  +    for i = 0 to len - 1 do
  +        action.Invoke (i, resizeArray1.[i], resizeArray2.[i])
  +
  +//
  +[<CompiledName("Map")>]
  +let inline map (mapping : 'T -> 'U) (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    resizeArray.ConvertAll (System.Converter mapping)
  +
  +//
  +[<CompiledName("MapIndexed")>]
  +let mapi (mapping : int -> 'T -> 'U) (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let mapping = FSharpFunc<_,_,_>.Adapt mapping
  +    let count = resizeArray.Count
  +    let result = ResizeArray (count)
  +
  +    for i = 0 to count - 1 do
  +        result.Add <| mapping.Invoke (i, resizeArray.[i])
  +    result
  +
  +//
  +[<CompiledName("Map2")>]
  +let map2 mapping (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>)
  +    : ResizeArray<'U> =
  +    // Preconditions
  +    checkNonNull "resizeArray1" resizeArray1
  +    checkNonNull "resizeArray2" resizeArray2
  +
  +    let len = length resizeArray1
  +    if len <> length resizeArray2 then
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let mapping = FSharpFunc<_,_,_>.Adapt mapping
  +    let results = ResizeArray (len)
  +
  +    for i = 0 to len - 1 do
  +        mapping.Invoke (resizeArray1.[i], resizeArray2.[i])
  +        |> results.Add
  +    results
  +
  +//
  +[<CompiledName("MapIndexed2")>]
  +let mapi2 mapping (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>)
  +    : ResizeArray<'U> =
  +    // Preconditions
  +    checkNonNull "resizeArray1" resizeArray1
  +    checkNonNull "resizeArray2" resizeArray2
  +
  +    let len = length resizeArray1
  +    if len <> length resizeArray2 then
  +        invalidArg "resizeArray2" "The ResizeArrays have different lengths."
  +
  +    let mapping = FSharpFunc<_,_,_,_>.Adapt mapping
  +    let results = ResizeArray (len)
  +
  +    for i = 0 to len - 1 do
  +        mapping.Invoke (i, resizeArray1.[i], resizeArray2.[i])
  +        |> results.Add
  +    results
  +
  +//
  +[<CompiledName("Fold")>]
  +let fold (folder : 'State -> 'T -> 'State) state (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let folder = FSharpFunc<_,_,_>.Adapt folder
  +
  +    let mutable state = state
  +    let count = resizeArray.Count
  +    for i = 0 to count - 1 do
  +        state <- folder.Invoke (state, resizeArray.[i])
       state
   
   //
  
positive.code: open ExtCore
  
  
  //
  [<CompiledName("Length")>]
  let inline length (resizeArray : ResizeArray<'T>) =
      resizeArray.Count
  
negative.code:     state
  
  //
  [<CompiledName("FoldIndexed")>]
  let foldi (folder : int -> 'State -> 'T -> 'State) state (resizeArray : ResizeArray<'T>) =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
  
      let mutable state = state
      let count = resizeArray.Count
      for i = 0 to count - 1 do
          state <- folder.Invoke (i, state, resizeArray.[i])
      state
  
  //
  [<CompiledName("Fold2")>]
  let fold2 folder (state : 'State)
      (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : 'State =
      // Preconditions
      checkNonNull "resizeArray1" resizeArray1
      checkNonNull "resizeArray2" resizeArray2
  
      let len = length resizeArray1
      if len <> length resizeArray2 then
          invalidArg "resizeArray2" "The arrays have different lengths."
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
      let mutable state = state
      for i = 0 to len - 1 do
          state <- folder.Invoke (state, resizeArray1.[i], resizeArray2.[i])
      state
  
  //
  [<CompiledName("FoldBack")>]
  let foldBack (folder : 'T -> 'State -> 'State) (resizeArray : ResizeArray<'T>) state =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
  
      let folder = FSharpFunc<_,_,_>.Adapt folder
  
      let mutable state = state
      for i = resizeArray.Count - 1 downto 0 do
          state <- folder.Invoke (resizeArray.[i], state)
      state
  
  //
  [<CompiledName("FoldBackSub")>]
  let foldBackSub folder (resizeArray : ResizeArray<'T>) startIndex endIndex (state : 'State) : 'State =
      // Preconditions
  