Transforming a byte array into an array of byte arrays with F# This code is intended to be used with an image manipulation library that I'm working on, and the goal is to take the raw byte[] data from an image, and transform it into a 2D array where each position on the array has a value corresponding to the pixel coordinates of the image. 

Comments concerning how to do this faster or more aligned with F# standards, or concerning style and formatting, are very much appreciated. I'm still learning F# so I need all the help I can get.

let Transform2D (pArrayWidth:int) (pArray:byte[]) = 
    let tHeight = pArray.Length / pArrayWidth
    let tImageArray = Array.zeroCreate&lt;byte[]&gt; tHeight

    let mutable tStart = 0
    let mutable tFinish = tStart + pArrayWidth - 1        // 0 indexed array

    for tRowIndex in [ 0 .. tHeight ] do
        tImageArray.[tRowIndex] &lt;- pArray.[tStart .. tFinish]
        tStart &lt;- tStart + pArrayWidth
        tFinish &lt;- tFinish + pArrayWidth

    tImageArray
You should consider whether byte[][] is really the best type to represent a bitmap in F#.

On one hand, arrays are inherently mutable and don't work well with pattern matching, so you might want to consider using list&lt;list&lt;byte&gt;&gt;, especially if performance is not critical.

On the other hand, a rectangular array of bytes is more accurately modeled as byte[,] (2D array), not byte[][] (array of arrays, a.k.a. jagged array). Though again, this is going to be slower than the original option.



for tRowIndex in [ 0 .. tHeight ] do


This has to be tHeight - 1, otherwise your code will fail with an exception.



let mutable tStart = 0
let mutable tFinish = tStart + pArrayWidth - 1        // 0 indexed array

for tRowIndex in [ 0 .. tHeight ] do
    tImageArray.[tRowIndex] &lt;- pArray.[tStart .. tFinish]
    tStart &lt;- tStart + pArrayWidth
    tFinish &lt;- tFinish + pArrayWidth

tImageArray


You can use sequence expressions to create arrays in a functional way. Here, that would look something like:

[|
    for tRowIndex in [ 0 .. tHeight - 1 ] do
        let tStart = tRowIndex * pArrayWidth
        let tFinish = tStart + pArrayWidth - 1
        yield pArray.[tStart .. tFinish]
|]


In both cases, a very similar syntax (for .. in) is used, but my version doesn't use any mutable variables and is very similar to list comprehensions in other functional languages.