anchor.diff:          else
               arr
   
  -    // Converts a jagged list into a jagged array
  +    /// Converts a jagged list into a jagged array
       let ofJaggedList (data: 'T list list) =
           data
           |> List.map (fun l -> l |> Array.ofList)
           |> Array.ofList
   
  -
  -    // Converts a jagged array into a jagged list
  +    /// Converts a jagged array into a jagged list
       let toJaggedList (arr: 'T [][]) =
           arr
           |> Array.map (fun a -> a |> List.ofArray)
           |> List.ofArray
   
  -    // Converts a jagged Seq into a jagged array
  +    /// Converts a jagged Seq into a jagged array
       let ofJaggedSeq (data: seq<#seq<'T>>) =
           data
           |> Seq.map (fun s -> s |> Array.ofSeq)
           |> Array.ofSeq
   
  -    // Converts a jagged array into a jagged seq
  +    /// Converts a jagged array into a jagged seq
       let toJaggedSeq (arr: 'T [][]) =
           arr
           |> Seq.map (fun s -> s |> Array.toSeq) 
   
  -    /// Shuffels each column of a jagged array separately  (method: Fisher-Yates)
  +    /// Builds a new jagged array whose inner arrays are the results of applying the given function to each of their elements.
  +    let map (mapping: 'T -> 'U) (jArray : 'T[][]) =
  +        jArray
  +        |> Array.map (fun x -> x |> Array.map mapping)
  +
  +    /// Builds a new jagged array whose inner arrays are the results of applying the given function to the corresponding elements of the inner arrays of the two jagged arrays pairwise. 
  +    /// All corresponding inner arrays must be of the same length, otherwise ArgumentException is raised.
  +    let map2 (mapping: 'T1 -> 'T2 -> 'U) (jArray1 : 'T1[][]) (jArray2 : 'T2[][]) = 
  +        jArray1
  +        |> Array.mapi (fun index x -> (Array.map2 mapping x jArray2.[index]))
  +
  +    /// Builds a new jagged array whose inner arrays are the results of applying the given function to the corresponding elements of the inner arrays of the tree jagged arrays triplewise. 
  +    /// All corresponding inner arrays must be of the same length, otherwise ArgumentException is raised.
  +    let map3 (mapping : 'T1 -> 'T2 -> 'T3 -> 'U) (jArray1 : 'T1[][]) (jArray2 : 'T2[][]) (jArray3 : 'T3[][]) =
  +        jArray1 |> Array.mapi (fun index x -> (Array.map3 mapping x jArray2.[index] jArray3.[index]))
  +
  +    ///Builds a new jagged array whose inner arrays 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 array being transformed.
  +    let mapi (mapping: int -> 'T -> 'U) (jArray : 'T[][]) =
  +        jArray
  +        |> Array.map (fun x -> x |> Array.mapi mapping)
  +
  +    ///Applies a function to each element of the inner arrays of the jagged array, threading an accumulator argument through the computation.
  +    let innerFold (folder: 'State -> 'T -> 'State) (state: 'State) (jArray : 'T[][]) =
  +        jArray
  +        |> Array.map (fun x -> x |> Array.fold folder state )
  +
  +    ///Applies a function to each element of the inner arrays of the jagged array, 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) ((jArray : 'T[][])) =
  +        jArray
  +        |> innerFold innerFolder innerState
  +        |> Array.fold outerFolder outerState
  +
  +    ///Returns a new jagged array whose inner arrays only contain the elements for which the given predicate returns true
  +    let innerFilter (predicate: 'T -> bool) (jArray: 'T[][]) =
  +        jArray
  +        |> Array.map (fun x -> x |> Array.filter predicate)
  +
  +    ///Applies the given function to each element in the inner arrays of the jagged array. Returns the jagged array whose inner arrays are comprised of the results x for each element where the function returns Some(x)
  +    let innerChoose (chooser: 'T -> 'U option) (jArray: 'T[][]) =
  +        jArray
  +        |> Array.map (fun x -> x |> Array.choose chooser)
  +
  +    /// Shuffles each column of a jagged array separately  (method: Fisher-Yates)
       let shuffleColumnWise (arr: 'T [][]) =
           if arr.Length > 0 then 
               let random      = new System.Random()
  
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()
  