Question

In pure functional programming the order of execution doesn’t matter and therefore is undetermined (i.e. it is up to the compiler). If you have side effects the order of execution does matter. So how can it be defined in F#?

I have a function that recursively deletes all empty subfolders of a given path. In addition it deletes some files contained in them if their names are in a given list.

The algorithm is easy:

1. Delete all files in the list.
2. Do the recursive call for the subfolders.
3. Delete the folder if it is empty. This must be the last step.

In addition the function returns the number of deleted elements as a tuple (numer of deleted folders, number of deleted files).

Here is my code:

let rec DeleteEmptyFolders path filenames =
    // Deletes a file or folder using the given function.
    // Returns 1 if the file could be deleted, otherwise 0.
    let Delete delete name =
        try
            delete name;
            1
        with
            | _ -> 0

    // The function result (number of deleted folders and files).
    let deletedFolders (a, _) = a
    let deletedFiles   (_, a) = a

    let accumulator a b = 
        ( deletedFolders a + deletedFolders b,
          deletedFiles a + deletedFiles b )

    // Deletes the given files and returns the number of deleted elements.
    let DeleteFiles folder names =
        names
        |> Seq.map (fun n -> Path.Combine (folder, n))
        |> Seq.map (fun n -> Delete File.Delete n)
        |> Seq.reduce (+)

    // Deletes the folder if it is empty
    // (Directory.Delete will fail if it is not empty).
    let DeleteFolder folder = Delete Directory.Delete folder

    // The recursive call
    let DeleteEmptySubFolders folder files =
        Directory.EnumerateDirectories folder
        |> Seq.map (fun p -> DeleteEmptyFolders p files)
        |> Seq.reduce (accumulator)

    // Three functions are executed: DeleteEmptySubFolders, DeleteFolder and DeleteFiles
    // But it has to be done in the correct order: DeleteFolder must be executed last.
    accumulator (DeleteEmptySubFolders path filenames) (DeleteFolder path, DeleteFiles path filenames)

I could figure out that DeleteEmptySubFolders is executed first, then DeleteFolder and DeleteFiles.
That is the order in which the functions appear in code. But I don’t think this is a rule of F#, it’s just what the compiler decided. It could be any other order.

Of course I can swap the elements in the last line of my code. The compiler would change the order of execution accordingly. But since this is not a rule of the language it would just be luck.

In another question on this topic I’ve read that values (i.e. functions without arguments) are initialized in the order in which they are declared.

let firstCall  = DeleteFiles path filenames
let secondCall = DeleteEmptySubFolders path filenames
let thirdCall  = DeleteFolder path

accumulator (secondCall) (thirdCall, firstCall)

Now the calls happen to be in the right order. But again: is this a rule of F# or just how the compiler works? (if the functions are not used the compiler might decide to not initialize the values at all)

How should I write the last line if I want to tell F# that the order of execution matters and when each call should be done? Is there a keyword or a special syntax to mark functions as not side effect free?

Answer 1

F# is not a pure functional programming language: functions and values will be computed top-to-bottom, left-to-right.