anchor.diff:          data
           |> Seq.map (fun s -> s |> List.toSeq) 
   
  -
  -
  +    /// Builds a new jagged list whose inner lists are the results of applying the given function to each of their elements.
  +    let map (mapping: 'T -> 'U) (jlist : 'T list list) =
  +        jlist
  +        |> List.map (fun x -> x |> List.map mapping)
  +
  +    /// Builds a new jagged list whose inner lists are the results of applying the given function to the corresponding elements of the inner lists of the two jagged lists pairwise. 
  +    /// All corresponding inner lists must be of the same length, otherwise ArgumentException is raised.
  +    let map2 (mapping: 'T1 -> 'T2 -> 'U) (jlist1 : 'T1 list list) (jlist2 : 'T2 list list) = 
  +        jlist1
  +        |> List.mapi (fun index x -> (List.map2 mapping x jlist2.[index]))
  +
  +    /// Builds a new jagged list whose inner lists are the results of applying the given function to the corresponding elements of the inner lists of the tree jagged lists triplewise. 
  +    /// All corresponding inner lists must be of the same length, otherwise ArgumentException is raised.
  +    let map3 (mapping : 'T1 -> 'T2 -> 'T3 -> 'U) (jlist1 : 'T1 list list) (jlist2 : 'T2 list list) (jlist3 : 'T3 list list) =
  +        jlist1 |> List.mapi (fun index x -> (List.map3 mapping x jlist2.[index] jlist3.[index]))
  +
  +    ///Builds a new jagged list whose inner lists are the results of applying the given function to each of their elements. The integer index passed to the function indicates the index of element in the inner list being transformed.
  +    let mapi (mapping: int -> 'T -> 'U) (jlist : 'T list list) =
  +        jlist
  +        |> List.map (fun x -> x |> List.mapi mapping)
  +
  +    ///Applies a function to each element of the inner lists of the jagged list, threading an accumulator argument through the computation.
  +    let innerFold (folder: 'State -> 'T -> 'State) (state: 'State) (jlist : 'T list list) =
  +        jlist
  +        |> List.map (fun x -> x |> List.fold folder state )
  +
  +    ///Applies a function to each element of the inner lists of the jagged list, threading an accumulator argument through the computation. 
  +    ///A second function is the applied to each result of the predeceding computation, again passing an accumulater through the computation 
  +    let fold (innerFolder : 'State1 -> 'T -> 'State1) (outerFolder : 'State2 -> 'State1 -> 'State2) (innerState : 'State1) (outerState : 'State2) ((jlist : 'T list list)) =
  +        jlist
  +        |> innerFold innerFolder innerState
  +        |> List.fold outerFolder outerState
  +
  +    ///Returns a new jagged list whose inner lists only contain the elements for which the given predicate returns true
  +    let innerFilter (predicate: 'T -> bool) (jlist: 'T list list) =
  +        jlist
  +        |> List.map (fun x -> x |> List.filter predicate)
  +
  +    ///Applies the given function to each element in the inner lists of the jagged List. Returns the jagged list whose inner lists are comprised of the results x for each element where the function returns Some(x)
  +    let innerChoose (chooser: 'T -> 'U option) (jlist: 'T list list) =
  +        jlist
  +        |> List.map (fun x -> x |> List.choose chooser)
  +
  +
  
positive.code: [<AutoOpen>]
  module JaggedArray =
      
      // Transposes a jagged array
      let transpose (arr: 'T [][]) =
          if arr.Length > 0 then 
              let colSize = arr.[0].Length
  
negative.code: 
  
  
      /// Shuffles each row of a jagged array separately  (method: Fisher-Yates)
      let shuffleRowWise (arr: 'T [][]) =
          if arr.Length > 0 then 
              let random      = new System.Random()
  