Transforming a byte array into an array of byte arrays with F#

Question

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<byte[]> tHeight

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

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

    tImageArray

Answer 1

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<list<byte>>, 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] <- pArray.[tStart .. tFinish]
    tStart <- tStart + pArrayWidth
    tFinish <- 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.