Table 10-2 shows the primary namespaces in .NET Framework DLLs from Table 10-1. In some cases, parts of these libraries are covered elsewhere in this book; the table notes these cases. For example, Chapter 4 introduced portions of the .NET I/O library from the System.IO namespace.

Table 10-3 shows the primary namespaces in F# library DLLs from Table 10-1. The following are opened by default in F# code:

Microsoft.FSharp.Core
Microsoft.FSharp.Collections
Microsoft.FSharp.Control
Microsoft.FSharp.Text

One of the most popular ways of working with strings as data is through the use of regular expressions. You do this using the functionality from the .NET System.Text.RegularExpressions namespace. To get started, first note that the F# library includes the following definition:

open System.Text.RegularExpressions
let regex s = new Regex(s)

To this, you can add the following Perl-like operators:

let (=˜) s (re:Regex) = re.IsMatch(s)
let (<>˜) s (re:Regex) = not (s =˜ re)

Here, the inferred types are as follows:

val regex : string -> Regex
val ( =~ ) : string -> Regex -> bool
val ( <>~ ) : string -> Regex -> bool

The infix operators allow you to test for matches:

> let samplestring = "This is a string";;
val samplestring : string

> if samplestring =~ regex "his" then
       printfn "A Match! ";;
A Match!
val it : unit = ()

Regular expressions can include *, +, and ? symbols for zero or more occurrences, one or more occurrences, and zero or one occurrences of the immediately preceding regular expression, respectively, and can include parentheses to group regular expressions. For example:

> "This is a string" =~ regex "(is )+";;
val it : bool = true

Regular expressions can also be used to split strings:

> (regex " ").Split("This is a string");;
val it : string [] = [|"This"; "is"; "a"; "string"|]

Here, you use the regular expression " " for whitespace. In reality, you probably want to use the regular expression " +" to match multiple spaces. Better still, you can match any Unicode whitespace character using s, including end-of-line markers; however, when using escape characters, you should use verbatim strings to specify the regular expression, such as @"s+". Chapter 3 discussed verbatim strings. Let's try this:

> (regex @"s+").Split("I'm a little      teapot");;
val it : string [] = [|"I'm"; "a"; "little"; "teapot"|]

> (regex @"s+").Split("I'm a little  		
	
	 teapot");;
val it : string [] = [|"I'm"; "a"; "little"; "teapot"|]

Here's how to match by using the method Match instead of using =~ and IsMatch. This lets you examine the positions of a match:

> let m = (regex @"joe").Match("maryjoewashere");;
val m : Match

> if m.Success then
     printfn "Matched at position %d" m.Index;;

Matched at position 4
val it : unit = ()

Replacing text is also easy:

> let text = "was a dark and stormy night";;
val text: string

> let t2 = (regex @"w+").Replace(text, "WORD");;
val t2: string  = "WORD WORD WORD WORD WORD WORD"

Here, you use the regular expression "w+" for a sequence of word characters.

Table 10-6 shows the broad range of specifiers you can use with .NET regular expressions.

You can specify case-insensitive matches by using (?i) at the start of a regular expression:

> samplestring =˜ regex "(?i)HIS";;
val it : bool = true

> samplestring =˜ regex "HIS";;
val it : bool = false

Here is a final example, showing the use of named groups:

let entry = @"
Jolly Jethro
13 Kings Parade
Cambridge, Cambs CB2 1TJ
"

let re =
 regex @"(?<=
)s*(?<city>[^
]+)s*,s*(?<county>w+)s+(?<pcode>.{3}s*.{3}).*$"

You can now use this regular expression to match the text and examine the named elements of the match:

> let r = re.Match(entry);;
val r : Match

> r.Groups.["city"].Value;;
val it : string = "Cambridge"

> r.Groups.["county"].Value;;
val it : string = "Cambs"

> r.Groups.["pcode"].Value;;
val it : string = "CB2 1TJ"

You can also combine regular expression matching with active patterns, described in Chapter 9. For example:

let (|IsMatch|_|) (re: string) (inp:string) =
    if Regex(re).IsMatch(inp)  then Some() else None

let (|MatchGroups|_|) (re: string) (inp:string) =
    let results = Regex(re).Match(inp)
    if results.Success then Some results.Groups else None

These active patterns can now be used as follows:

> match "This is a string" with
| IsMatch "(?i)HIS" -> "yes, it matched"
| IsMatch "ABC" -> "this would not match"
| _ -> "nothing matched"

val it : string = "yes, it matched "

> match "This is a super string" with
  | MatchGroups "(?<word1>Tw+).*(?<word2>sw+)" groups ->
      (groups.["word1"].Value, groups.["word2"].Value)
  | _ -> failwith "nothing matched"

val it : string * string = ("This", "string")

Finally, you can use the dynamic operator, also defined in Chapter 9, to make the lookups slightly more natural:

> match "This is a string is super" with
  | MatchGroups "(?<word1>Tw+).*(?<word2>sw+)" groups -> (groups?word1, groups?word2)
  | _ -> failwith "nothing matched"

val it : string * string = ("This", "super")

Throughout this book, you've used F# printf format strings to format text and output; Chapter 4 introduced the basic format specifiers for this kind of text formatting. Functions such as printf and printfn are located in the Microsoft.FSharp.Text.Printf module.

Another way to format strings is to use the System.String.Format static method or the other .NET composite formatting functions such as System.Console.WriteLine and TextWriter.WriteLine. This is a distinct set of formatting functions and directives redesigned and implemented from the ground up for the .NET platform. Like printf, these methods take a format specifier and the objects to be formatted. The format specifier is a string with any number of format items acting as placeholders and designating which object is to be formatted and how. Consider the following simple example:

> System.String.Format("{0} {1} {2}", 12, "a", 1.23);;
val it : string = "12 a 1.23"

Each format item is enclosed in braces giving the index of the object to be formatted, and each can include an optional alignment specification (always preceded by a comma after the index, giving the width of the region in which the object is to be inserted, as in {0, 10}) and a format type that guides how the given object is formatted (as in {0:C}, where C formats as a system currency). The general syntax of the format item is as follows:

{index[,alignment][:formatType]}

You can use the alignment value to pad the formatted object with spaces; text alignment is left if its value is negative and right if positive. Table 10-7 summarizes the most often used format types.

You can find more information about .NET composite formatting at www.expert-fsharp.com/Topics/ TextFormatting.

It's often necessary to convert string data between different formats. For example, files read using the ReadLine method on the System.IO.StreamReader type are read with respect to a Unicode encoding. You can specify this when creating the StreamReader; if left unspecified, the .NET librariesattempt to determine the encoding for you.

One common requirement is to convert strings to and from ASCII representations, assuming that all the characters in the strings are in the ASCII range 0 to 127. You can do this using System.Text.Encoding.ASCII.GetString and System.Text.Encoding.ASCII.GetBytes. Table 10-8 shows the predefined encodings and commonly used members in the System.Text.Encoding type.

Another common requirement is to convert binary data to and from the standard 64-character string-encoded representation of binary data used in XML, e-mail, and other formats. You can do this using System.Convert.FromBase64String and System.Convert.ToBase64String.

Table 10-10 summarizes the imperative collections available in the System.Collections.Generic namespace.

The F# Power Pack includes matrix and column vector types, which are generic and called Matrix<'T> and Vector<'T>, respectively. For symmetry, a type of row vectors, RowVector<'T>, is also included. Most commonly, the element types are instantiated to be double (that is, float), so the following abbreviations are used:

type vector = Vector<float>
type matrix = Matrix<float>
type rowvec = RowVector<float>

The modules Matrix, Vector, and RowVector in the Microsoft.FSharp.Math namespace have many additional functions for creating and working with these types. The functions are specialized for use with floating-point matrices, but versions to work with generic types are available at Microsoft.FSharp.Math.Matrix.Generic and Microsoft.FSharp.Math.Vector.Generic. The functions vector and matrix are also available for creating literal values. Here are some examples that use these types and functions:

> #r "FSharp.PowerPack.dll";;

> open Microsoft.FSharp.Math;;

> vector [ 1.0; 2.0 ; 3.0 ] + vector [ 1.0; 2.0 ; 3.0 ];;
val it : Vector<float> = vector [2.0; 4.0; 6.0]

matrix [ [ 1.0; 2.0 ];
           [ 1.0; 3.0 ] ]
  *
  matrix [ [ 1.0; −2.0 ];
           [ 0.5; 3.0 ] ];;
val it : Math.matrix = matrix [[2.0; 4.0];
                               [2.5; 7.0];]

Table 10-11 summarizes the primary properties of these types.

The F# matrix, vector, and row vector types support the use of operators such as +, -, and *. Table 10-12 sxshows some of the overloads supported.

There are a number of facets to reflective programming with .NET. In one simple kind of reflective programming, a range of data structures are accessed in a general way. For example, .NET includes a type System.Array that is a parent type of all array types. The existence of this type allows you to write code that is generic over all array types, even one-dimensional and multidimensional arrays. This is occasionally useful, such as when you're writing a generic array printer.

Table 10-14 summarizes the primary general types defined in the .NET Framework.

In Chapter 9, the schema compiler used functions from the Microsoft.FSharp.Reflection namespace. This namespace is a relatively thin extension of the System.Reflection namespace. It offers an interesting set of techniques to create and analyze F# values and types in ways that are somewhat simpler than those offered by the System.Reflection namespace. These operations are also designed to be used in precompilation phases to amortize costs associated with reflective programming.

Table 10-15 summarizes the two types in this namespace