F#3 : Formatting text

One of the things you will most likely need to do when you work with any language is format text, and surprise surprise F# is no different.

Since F# is a .NET language we can always make use of Console.WriteLine(..) and String.Format(..) where we could use any of the regular formatters that you have used in your regular .NET code.

However F# also supports a more C syntax like technique which is available within the Core.Printf module. One function within that can be used instead of the Console.WriteLine(..) .NET class usage.

The F# equivalent function that you would use to write to the standard output is printfn, which is actually the preferred method when dealing with text formatting in F#.

Why is printfn preferred over Console.WriteLine(..) ?

There are several reasons that printfn is preferred, some of the main reasons are shown below:

• Static type checking. Which means if we pass an int value where a string is expected, we are warned about this
• As printfn is a native F# function, is acts just like any other F# function. Where you do certain F# things, such as possibly partially applying the function (which is something we will try and cover a bit more in a subsequent post)
• It will have baked in support for standard F# types

Lets just spend a bit more time on the statically typed point above. Consider the following code snippets

// incorrect type
printfn "should be a decimal value %d" "cat"
//this works
printfn "should be a decimal value %d" 42
// incorrect type but works
Console.WriteLine("should be a decimal value {0}" , "cat")


// wrong number of parameters provided
printfn "this only expected 1 arg of type decimal %d" 42 "dog"
// wrong number of parameters provided but works
Console.WriteLine("this only expected 1 arg of type decimal {0}" , 42, "dog")
// this works as expected
printfn "this only expected 2 args of type decimal %d and string %s" 42 "dog"

If we now look at a screen shot of this code actually in the Visual Studio IDE, we can indeed see that the lines that we expected to fail are clearly shown as being in error:

How we use printfn?

So now that we know why we should use printfn, how do we use it?

Well probably the best place to start is by looking at some of the standard formatters available when dealing with values. The following table illustrates the standard operators that are available to you:

I have taken these directly from MSDN : http://msdn.microsoft.com/en-us/library/ee370560.aspx

I would recommend you have a look at that MSDN link, as it contains additional information that may be useful when you need to do some fine grained formatting.

So what about creating nice formatting other than standard out

So we have now seen how to write nicely formatted output to the standard output (printfn did this), but what about if we wanted to use formatted string in other places? What if we wanted to bind a string value to a nicely formatted string that we constructed using some of the formatters above, or even wanted to write to a StringBuilder or TextWriter, does F# enable us to do that easily?

Well yes actually it does, you will find a great many other useful functions in the Core.Printf module. The full list at time of writing this post was as follows:

I am not going to through all of these but I will go through the most common ones:

bprintf

Prints to a StringBuilder.

let builder = new StringBuilder(524288)
Printf.bprintf builder "This will be a string line : %s\r\n" "cat" 
Printf.bprintf builder "This will be a bool line : %b\r\n" true
Printf.bprintf builder "This will be a int line : %u\r\n" 42
Printf.bprintf builder "This will be a hex line : %X\r\n" 255

printfn "%s" (builder.ToString())

This will give this output in a F# Console Application

fprintf

Prints to a text writer.

use sw = new StreamWriter(@"c:\temp\fprintfFile.txt")

fprintf sw "This is a string line %s\r\n" "cat"
fprintf sw "This is a int line %i" 10

sw.Close()

This will result in a file being created in temp

sprintf

Prints to a string by using an internal string buffer and returns the result as a string. Helper printers must return strings.

let result = Printf.sprintf "This will return a formatted string : %s\r\n" "cat" 
printfn "%s" result

This will give this output in a F# Console Application