Refactoring while-do into tail recursion with F#

Question

I have a while-do loop nested inside a while-do loop in my program, due to it needing to iterate in two dimensions through an array of arrays, and originally my loop looked like this:

while ( tHeightIndex < tSearchHeight - 1 ) && tContinue do
 while ( tWidthIndex < tSearchWidth - 1 ) && tContinue do
 let tCurrentValue = tLargeArray.[tHeightIndex].[tWidthIndex]
 if tCurrentValue = tFirstSmallPixel then
 tMatch <- ArrayFunctions.SearchSubset tSmallArray tLargeArray ( tHeightIndex, tWidthIndex )
 if tMatch then tContinue <- false
 if tMatch = false && tContinue = true then
 tWidthIndex <- tWidthIndex + 1
 if tMatch = false && tContinue = true then
 tWidthIndex <- 0 // Reset to search next row
 tHeightIndex <- tHeightIndex + 1
tMatch, tWidthIndex, tHeightIndex

However, seeing as I'm doing this project entirely to learn better functional programming practices, I refactored that nested loop into two tail-recursive functions. This code passes my unit tests and appears to work correctly, so I would like advice about the style of the code and whether there's better ways I can make the code read clearly.

The relevant part to the original while-do loop is located after the declaration of firstSmallPixel.

module ImageSearch = 
 open ImageFunctions
 let SearchBitmap (smallBitmap:Bitmap) (largeBitmap:Bitmap) = 
 let smallArray = Transform2D <| LoadBitmapIntoArray smallBitmap 
 let largeArray = Transform2D <| LoadBitmapIntoArray largeBitmap
 let searchWidth = largeBitmap.Width - smallBitmap.Width
 let searchHeight = largeBitmap.Height - smallBitmap.Height
 let firstSmallPixel = smallArray.[0].[0]
 let WidthLoop heightIndex =
 let rec WidthLoopRec heightIndex widthIndex =
 let ContinueLoop () = WidthLoopRec heightIndex (widthIndex + 1)
 let currentLargePixel = largeArray.[heightIndex].[widthIndex]
 match ( widthIndex < searchWidth , currentLargePixel = firstSmallPixel ) with
 | ( true , true ) -> let foundImage = ArrayFunctions.SearchSubset smallArray largeArray ( heightIndex, widthIndex )
 if foundImage then widthIndex , foundImage
 else ContinueLoop ()
 | ( true , false ) -> ContinueLoop ()
 | ( false, _ ) -> widthIndex , false
 WidthLoopRec heightIndex 0 
 let HeightLoop () =
 let rec HeightLoopRec heightIndex =
 let widthIndex, foundImage = WidthLoop heightIndex
 match ( foundImage, heightIndex < searchHeight ) with
 | ( false , true ) -> HeightLoopRec ( heightIndex + 1 ) 
 | ( _ , _ ) -> foundImage , widthIndex , heightIndex
 HeightLoopRec 0 
 HeightLoop ()

Answer 1

I think that learning functional programming should be about making your code more readable (and also better in other aspects), neither of your samples seems very readable to me.

I also think that when working with collections in functional programming, the most important concept is not recursion, it's higher-order functions.

If you use those in the form of a query expression, your code could look like this:

query {
 for row in 0..searchHeight do
 for col in 0..searchWidth do
 let pixel = largeArray.[row].[col]
 where (pixel = firstSmallPixel)
 select (row, col, pixel)
 head
}

The nice thing about this code is not only that it's more readable and shorter, it's that it emphasizes what you want to do, not how to do it.