Programming F 3 0 Second Edition Chris Smith

download

https://ebookname.com/product/programming-f-3-0-second-edition-
chris-smith/

Get Instant Ebook Downloads – Browse at https://ebookname.com

Instant digital products (PDF, ePub, MOBI) available
Download now and explore formats that suit you...

Programming C Sharp 3 0 5th Edition Jesse Liberty

https://ebookname.com/product/programming-c-sharp-3-0-5th-
edition-jesse-liberty/

ASP NET 3 5 Website Programming Chris Love

https://ebookname.com/product/asp-net-3-5-website-programming-
chris-love/

OpenGL Es 3 0 Programming Guide 2nd Edition Daniel

Ginsburg

https://ebookname.com/product/opengl-es-3-0-programming-
guide-2nd-edition-daniel-ginsburg/

The Japan That Never Was Explaining the Rise and

Decline of a Misunderstood Country 1st Edition Dick
Beason

https://ebookname.com/product/the-japan-that-never-was-
explaining-the-rise-and-decline-of-a-misunderstood-country-1st-
edition-dick-beason/
The international encyclopedia of ethics Volume 3 D Fal
1st Edition Hugh Lafollette

https://ebookname.com/product/the-international-encyclopedia-of-
ethics-volume-3-d-fal-1st-edition-hugh-lafollette/

Frommer s Portable Maine Coast Frommer s Portable 4th

Edition Paul Karr

https://ebookname.com/product/frommer-s-portable-maine-coast-
frommer-s-portable-4th-edition-paul-karr/

Technical Capabilities Necessary for Regulation of

Systemic Financial Risk Summary of a Workshop 1st
Edition National Research Council

https://ebookname.com/product/technical-capabilities-necessary-
for-regulation-of-systemic-financial-risk-summary-of-a-
workshop-1st-edition-national-research-council/

The Other Jesus Christology in Asian Perspective

Studien zur interkulturellen Geschichte des
Christentums Etudes d histoire interculturelle du in
the Intercultural History of Christianity John Parratt
https://ebookname.com/product/the-other-jesus-christology-in-
asian-perspective-studien-zur-interkulturellen-geschichte-des-
christentums-etudes-d-histoire-interculturelle-du-in-the-
intercultural-history-of-christianity-john-parratt/

Political Theory Without Borders 1st Edition Robert E.

Goodin

https://ebookname.com/product/political-theory-without-
borders-1st-edition-robert-e-goodin/
Democracy and the Rule of Law in Classical Athens
Essays on Law Society and Politics Edward M. Harris

https://ebookname.com/product/democracy-and-the-rule-of-law-in-
classical-athens-essays-on-law-society-and-politics-edward-m-
harris/
O’Reilly Media, Inc. 4/2/2012

Preface

Have you ever been in a hurry and pounded in a nail using something other than a
hammer? Or perhaps settled an argument concerning distances with “the length of my
arm is about 20 inches, and that’s about two arm-lengths…?” You might not be willing to
fall for such obviously flawed short-cuts, but as your humble author I will admit that I
have.
There is elegance to using the right tool for the job. And, just like a hammer or a tape
measure, programming languages are tools like any other. Throughout this book you will
discover that while F# isn’t the best tool for every situation, it is the perfect tool for some
situations.
This book is about showing you how to use the F# programming language as a general-
purpose tool, with an emphasis on the specific domains where it can lead to dramatic
boots in productivity.
Along the way you will pick up a knack for functional programming; a semi-mysterious
collections of concepts that can help you rethink your programs regardless of the host
programming language.

Introducing F#
So what actually is F#? In a nutshell, F# is a multi-paradigm programming language built
on .NET, meaning that it supports several different styles of programming natively. I’ll
spare you the history of the language and instead just go over the big bullets:
• F# supports imperative programming. In F# you can modify the contents of memory,
read and write files, send data over the network, and so on.
• F# supports object-oriented programming. In F# you can abstract code into classes
and objects enabling you to simplify your code.
• F# supports functional programming, which is a style of programming which
emphasizes what a program should do, not explicitly how the program should work.
• F# is statically typed. Being statically typed means that type information is known at
compile time, leading to type-safe code. F# won’t allow you to put a square peg into
a round hole.
• F# is a .NET language. It runs on the Common Language Infrastructure (CLI) and so
it gets things like garbage collection (memory management) and powerful class

1
O’Reilly Media, Inc. 4/2/2012

libraries for free. F# also supports all .NET concepts natively, such as delegates,
enumerations, structures, P/Invoke, and so on.
Even without all the jargon, it is clear that F# is powerful language. But don’t worry;
we’ll cover it all step by step.

Who This Book Is For

This book isn’t intended to be an introductory text on programming and assumes
familiarity with basic concepts like looping, functions, and recursion. However, no
previous experience with functional programming or .NET is required.
If you come from a C# or VB.NET background then you should feel right at home. While
F# approaches programming from a different viewpoint, you can apply all of your
existing .NET know-how to programming in F#.
If you come from an OCaml or Haskell background then the syntax of F# should look
very familiar. F# has most of the features of those languages, and adds many more to
integrate well with .NET.

What You Need to Get Going

F# is “in the box” of Visual Studio 11. This includes the F# compiler and project system,
and contains all the features such as syntax highlighting and IntelliSense that you would
expect. Outside of Visual Studio and on non-Microsoft platforms, you can still write and
deploy F# applications using the open source Mono platform (http://www.mono-
project.com/).
If you are running F# on Windows, then the first chapter of this book will show you how
to get set up using Visual Studio. Otherwise, Appendix A will walk you through getting
F# set up on non-Microsoft platforms.
Also, it is important to note that all of the examples printed in this book (as well as many
more) may be found on GitHub. The best way to learn any new skill is to just start using
it, so I highly recommended that you take a moment to fork and explore the repository for
this book’s source code at: http://github.com/aChrisSmith/Programming-FS-Examples/.

How the Book Is Organized

This book is divided into three parts. Part I focuses on multi-paradigm programming in
F#. Early chapters will be devoted to programming in a specific F# paradigm, while later
ones will help flesh out your understanding of language capabilities. By the end of Part I
you will be fluent in the F# language and its idioms.
Part II will introduce a few lingering concepts but primarily focus on applying F# in
specialized areas. By the end of Part II you will know how to utilize F# as a scripting
language, for parallel programming, and for creating domain specific languages.
Part III should be considered optional for most F# developers, and focuses on advanced
language features that allow you to modify and extend the F# language.

2
O’Reilly Media, Inc. 4/2/2012

Part I, Multi-Paradigm Programming

Chapter 1, Introduction to F#, presents the F# language and the Visual Studio 11
integrated development environment (IDE). Even if you are familiar with Visual Studio I
recommend you read this chapter as F# has some unique characteristics when it comes to
building and running projects.
Chapter 2, Fundamentals, introduces the core types and concepts which will be the
foundation for all other chapters.
Chapter 3, Functional Programming, introduces functional programming and how to
write F# code using this style.
Chapter 4, Imperative Programming, describes how to mutate values and change
program state in an imperative manner.
Chapter 5, Object-oriented Programming, covers object-oriented programming from
creating simple types to inheritance and polymorphism.
Chapter 6, .NET Programming, goes over some style independent concepts exposed by
the .NET Framework and CLI.

Part II, Programming F#

Chapter 7, Applied Functional Programming, covers more advanced topics in functional
programming such as tail recursion and functional design patterns.
Chapter 8, Applied Object-Oriented Programming, describes how to develop and take
advantage of a rich type system. Special attention will be paid on how to leverage the
functional aspects of F# to make object-oriented code better.
Chapter 9, Asynchronous and Parallel Programming, takes a look at how to use F# to
take advantage of multiple cores on a processor and the facilities in the F# and .NET
libraries for parallel programming.
Chapter 10, Scripting, examines F# as a scripting language and how to make the most of
F# script files.
Chapter 11, Data Processing, focuses exclusively on using F# in “real world” scenarios
for doing distributed computations, interacting with web services, and working in
information-rich environments.

Part III, Extending the F# Language

Chapter 12, Reflection, provides a look at the .NET reflection library and how to use it to
create declarative programs.
Chapter 13, Computation Expressions¸ introduces an advanced F# language feature
which will enable you to eliminate redundant code and add new capabilities to the core
F# language.
Chapter 14, Quotations, introduces F# quotation expressions and how they can be used to
do metaprogramming as well as execute F# code on other computational platforms.

3
O’Reilly Media, Inc. 4/2/2012

Chapter 15, Type Providers, explains the F# compiler’s special machinery for integrating
typed data across multiple domains. (Don’t fret, that sentence will make sense when you
start the chapter.)
Appendixes
This book also features a couple of appendixes to flesh out any extra concepts you might
be interested in.
Appendix A, Overview of the .NET Libraries, does a quick sweep through the existing
technologies available on the .NET platform and how to use them from F#.
Appendix B, F# Interop, covers how to write F# to interoperate with existing libraries as
well as unmanaged code using P/Invoke and COM-interop.

Conventions Used in This Book

The following font conventions are used in this book:
Italic
Used for new concepts as they are defined.
Constant width
Used for code examples and F# keywords.
Constant width bold
Used for emphasis within program code.
Pay special attention to note styles within this text.

Notes like this are used to add more detail to the curious reader.

Warnings are indicated in this style are to help you avoid common
mistakes.

I’d Like to Hear from You

Although I’ve tested and verified the information in this book, you may find some
aspects of the F# language has changed since the writing (or perhaps even a bug in the
example!) Please let me know of any errors you find, as well as your suggestions for
future editions, at: http://oreilly.com/catalog/errata.csp?isbn=9780596153656.
In addition, you can use analog-mail by writing to:
O’Reilly Media, Inc.
1005 Gravenstein Highway North
Sebastopol, CA 95472
(800) 998-9938 (in the U.S. or Canada)
(707) 829-0515 (international/local)

4
O’Reilly Media, Inc. 4/2/2012

(707) 829-0104 (fax)

You can also send messages electronically. To be put on the mailing list or request a
catalog, send email to:
[email protected]
To comment on the book, send email to:
[email protected]
For information about this book and others, as well as additional technical articles and
discussion on F#, see the O’Reilly website:
http://www.oreilly.com
or the O’Reilly .NET DevCenter:
http://www.oreillynet.com/dotnet
or the Microsoft Developer Network portal for F#:
http://www.msdn.com/fsharp

Safari® Books Online

When you see a Safari® Books Online icon on the cover of your favorite technology
book it means the book is available online through the O’Reilly Network Safari
Bookshelf.
Safari offers a solution that’s better than e-books. It’s a virtual library that lets you easily
search thousands of top tech books, cut and paste code samples, download chapters, and
find quick answers when you need the most accurate, current information. Try it for free
at http://my.safaribooksonline.com.

Acknowledgments
In addition to the F# team at Microsoft for putting out a fantastic product, I’d like to
thank the following people for helping make the second edition of this book awesome:
Matt Douglass-Riely X

5
O’Reilly Media, Inc. 4/2/2012

Preface
Preface to the Second Edition

Hello! I’m writing this about three-years to the day that the first edition of Programming
F# came out. (And about one year before the second edition will be generally available.)
And it has been quite an experience.
Three years ago F# was just about to get its first official release in Visual Studio 2010.
Everyone on the team knew that developers would love our language, but we weren’t
sure where it would go. How it would be preceived.
But F# has not only been loved, it’s also achieved several important milestones. The first
one, was that this last year at the International Conference on Functional Programming
F# received the title as “the language for discriminating hackers”. While the
programming competition and “award” are just for fun, it demonstates that the language
isn’t just a toy.
Outside of the F# language front, the applications are growing. Job boards for F#
programmers are getting almost to much attention from head-hunters and recrutiers
aggressively looking to put F# developers in data mining, finance, and other technical
positions.
With that as the backdrop, there were a few key changes to the book for this second
edition aside from incorporating language advances for the F# 3.0 release.
First of all is the emphasis on more real-world examples. The first edition did a good job
of being a concise reference for the core language, but some readers left unsure of how to
actually apply F# to projects. This time around I’ve written dozens of large-scale
applications. To save space – again, to be concise – I’ve posted all the code on gitHub so
you can browse it freely and at your own pace at (github.com/achrissmith/programming-
fsharp/).
While with the explosive growth of mobile computing, F# in use as a server backend for
websites, and the unknown Windows 8 and the “Metro” UI style. It’s an exciting time to
be learning F# again!

1
O’Reilly Media, Inc. 4/2/2012

-Chris Smith
10/2011
Redmond, WA

2
O’Reilly Media, Inc. 4/2/2012

Part I
Multi-Paradigm Programming

1
O’Reilly Media, Inc. 4/2/2012

1
Introduction to F#

F# is a powerful language that spans multiple paradigms of development. This chapter

provides a brief introduction to the heart of F# – the F# compiler, tools, and its place in
Visual Studio 11.
In this chapter, you will create a couple of simple F# applications and then I’ll point out
key Visual Studio features for F# development. I won’t cover much of Visual Studio
here, so I encourage you to explore the IDE on your own.
If you are already familiar with Visual Studio, you should still skim through this chapter.
Creating and debugging F# projects works just like C# or VB.NET; however, F# has a
unique characteristic when it comes to multiple-file projects. In addition, F# has a feature
called F# Interactive which will dramatically increase your productivity. Not to be
missed!

Getting to Know F#
As with all programming books, it is customary to write a Hello, World application, and I
don’t want to deviate from tradition. Open up Notepad or your favorite text editor and
create a new file named HelloWorld.fs with the following text:
// HelloWorld.fs

printfn "Hello, World"

Success! You’ve just written your first F# program. To compile this application use the
F# compiler, fsc.exe, located in the Program Files (x86)\Microsoft
SDKs\F#\3.0\Framework\v4.0 folder. (Don’t worry, you won’t have to
remember that.)
The following snippet shows calling the F# compiler on the command line to build and
run your application.
C:\Programming F# Source\Ch01>fsc HelloWorld.fs
Microsoft (R) F# 3.0 Compiler build 4.0.30319.16909

` 1
O’Reilly Media, Inc. 4/2/2012

Copyright (c) Microsoft Corporation. All Rights Reserved.

C:\Programming F# Source\Ch01>HelloWorld.exe
Hello, World!

Visual Studio 11
Tools are the lifeblood of any programming language, and F# is no different. While you
can be successful writing F# code in your favorite text editor and invoking the compiler
from the command line, you’ll likely be more productive using tools. Like C# and
VB.NET, F# is a first-class citizen in Visual Studio with all the features that you might
expect, such as debugger support, IntelliSense, project templates, and so on.

Alternatively, you can try F# out in your browser at

http://www.tryfsharp.org/.

Let’s revisit our Hello, World application, but this time using Visual Studio.
To create your first F# project, open up the Visual Studio IDE and select File → New
Project from the menu bar to open the New Project dialog, as shown in Figure 1-1. Select
Visual F# in the left pane, select F# Application in the right pane, and then click OK.

Figure 1-1. Select F# Application to start your first F# project

After you click OK in the New Project dialog, you’ll see an empty code editor – a blank
canvas ready for you to create your F# masterpiece. Next, type the following code into
the F# editor:
printfn "Hello, World"
Now press Control + F5 to run your application. When your application starts, a console
window will appear and display the entirely unsurprising result shown in Figure 1-2.

` 2
O’Reilly Media, Inc. 4/2/2012

Figure 1-2. Hello World in F#

Your Second F# Program

It may be startling to see a program work without an explicit Main method. You will see
why this is admissible in the next chapter, but for now let’s create a more meaningful
Hello, World-type program to get a feel for basic F# syntax.
The code in Example 1-1 will create a program that accepts two command-line
parameters and prints them to the console. In addition, it displays the current time.
Example 1-1. Mega Hello World
// Mega Hello World
//
// Take two command line parameters and then print
// them along with the current time to the console.

open System

[<EntryPoint>]
let main (args : string[]) =

if args.Length <> 2 then

failwith "Error: Expected arguments <greeting> and <thing>"

let greeting, thing = args.[0], args.[1]

let timeOfDay = DateTime.Now.ToString("hh:mm tt")

printfn "%s, %s at %s" greeting thing timeOfDay

// Program exit code

0
Hopefully you are curious about what is going on. Let’s look at this program line-by-line
to see how it works.

` 3
O’Reilly Media, Inc. 4/2/2012

Values
Example 1-1 introduces three values named greeting, thing, and timeOfDay.
let greeting, thing = args.[0], args.[1]
let timeOfDay = DateTime.Now.ToString("hh:mm tt")

The key thing here is that the let keyword binds a name to a value. It is worth pointing
out that unlike most other programming languages, in F# values are immutable by
default, meaning they cannot be changed once initialized. We will cover why values are
immutable in Chapter 3, but for now it is sufficient to say it has to do with “functional
programming”.
F# is also case-sensitive, so any two values with names that only differ by case are
considered different.
let number = 1
let Number = 2
let NUMBER = 3

A value’s name can be any combination of letters, numbers, underscores _, and

apostrophes '. However, the name must begin with a letter or an underscore.

You can enclose the value’s name with a pair of tick-marks, in which
case the name can contain any character except for tabs and new lines.
This allows you to refer to values and functions exposed from other
.NET languages that may conflict with F# keywords.
let ``this.Isn’t %A% good value Name$!@#`` = 5

Whitespace Matters
Other languages like C# use semicolons and curly braces to indicate when statements and
blocks of code are complete. However, programmers typically indent their code to make
it more readable anyways, so these extra symbols often just add syntactic clutter.
In F#, whitespace – spaces and newlines – is significant. The F# compiler allows you to
use whitespace to delimit code blocks. For example, anything indented more than the if
keyword is considered to be in the body of the if statement. Because tab characters can
indicate an unknown number of space characters, they are prohibited in F# code.

You can configure the Visual Studio editor to automatically convert tab
characters into spaces by changing the relevant setting under Tools →
Options → Text Editor → F#.

Reviewing Example 1-1, notice that the body of the main method was indented by four
spaces, and the body of the if statement was indented by another four spaces.
let main (args : string[]) =

if args.Length <> 2 then

failwith "Error: Expected arguments <greeting> and <thing>"

let greeting, thing = args.[0], args.[1]

let timeOfDay = DateTime.Now.ToString("hh:mm tt")

` 4
O’Reilly Media, Inc. 4/2/2012

printfn "%s, %s at %s" greeting thing timeOfDay

// Program exit code

0

If the body of the if statement, the failwith "..." expression, was dedented four
spaces and therefore lined up with the if keyword, the F# compiler would produce a
warning. This is because the compiler wouldn’t be able to determine whether the
failwith was meant for the body of the if statement or the main function.
[<EntryPoint>]
let main (args : string[]) =

if args.Length <> 2 then

failwith "Error: Expected arguments <greeting> and <thing>"

Warning FS0058: Possible incorrect indentation: this token is offside of

context started at position (25:5). Try indenting this token further or
using standard formatting conventions.
The general rule is that anything belonging to a method or statement must be indented
further than the keyword that began the method or statement. So in Example 1-1
everything in the main method was indented past the first let and everything in the if
statement was indented past the if keyword. As you see and write more F# code you
will quickly find that omitting semicolons and curly braces makes the code easier to write
and much easier to read.

.NET Interop
Example 1-1 also demonstrates how F# can interoperate with existing .NET libraries.
open System

// ...

let timeOfDay = DateTime.Now.ToString("hh:mm tt")

This example shows the DateTime.Now property from the System namespace in the
mscorlib.dll assembly in use.
The .NET Framework contains a broad array of libraries for everything from graphics to
databases to web services. F# can take advantage of any .NET library natively by calling
directly into it. Conversely, any code written in F# can be consumed by other .NET
languages. This also means that F# applications can run on any platform that supports
.NET. So the F# programs you write can run on phones, tablets, PCs, and so on.

For more information on .NET libraries see Appendix A, Overview of

.NET Libraries. for a quick tour of what’s available. For more
information about F# inter-operating with other .NET languages refer
to Appendix B, F# Interop.

Comments
F# allows you to comment your code. To declare a single-line comment use two slashes
//; everything after them until the end of the line will be ignored by the compiler.

` 5
O’Reilly Media, Inc. 4/2/2012

// Program exit code

For larger comments you can use (* and *). Everything between the two tokens will be
ignored.
(*
Comment
spanning
multiple
lines
*)
For F# applications written in Visual Studio, there is a third type of comment – an XML
documentation comment. If a comment starting with three slashes, ///, is placed above
an identifier, Visual Studio will display the comment’s text when you hover the mouse
over the identifier.
Figure 1-3 shows applying an XML documentation comment and its associated tooltip.

Figure 1-3. XML documentation comments

F# Interactive
So far you have written some F# code and executed it, and the rest of the book will have
many more examples. While you could leave a wake of new projects to test out code,
Visual Studio comes with a tool called F# Interactive or FSI. The FSI window will not
only make it much easier to work through the examples in this book, but it will also help
you write applications.
F# Interactive is a tool known as a REPL, which stands for read, evaluate, print, loop. It
accepts F# code, compiles and executes it, then prints the results. This allows you to
quickly and easily experiment with F# without needing to create new projects or build a
full application to test the results of a code snippet.
Most Visual Studio configurations launch the F# Interactive window with the
Control+Alt+F keyboard combination. Once the FSI window is available, it accepts F#

` 6
O’Reilly Media, Inc. 4/2/2012

code until you terminate the input with ;; and a newline. The code entered is compiled
and executed as shown in Figure 1-4.
The FSI window prints any new values introduced as well as their types. Figure 1-4
shows val x : int = 42, declaring that a value x of type int was created with
value 42. If the FSI window evaluates an expression that was not assigned to a value, it
will instead assign it to the name it.

Figure 1-4. The F# Interactive window

As the F# compiler processes FSI input it will display the name, type, and value of
identifiers. For example, in Figure 1-4 the value x was introduced with type int and
value 42.

If you are running F# without Visual Studio, you can find the console
version of F# Interactive in the same directory you found fsc.exe
with the name fsi.exe.

Try running these other snippets in FSI. Remember that every code snippet is terminated
with a ;;.
> 2 + 2;;
val it : int = 4
> // Introduce two values
let x = 1
let y = 2.3;;

val x : int = 1

` 7
O’Reilly Media, Inc. 4/2/2012

val y : float = 2.3

> float x + y;;

val it : float = 3.3
> let cube x = x * x * x;;

val cube : int -> int

> cube 4;;

val it : int = 64
FSI can dramatically simplify testing and debugging your applications because you can
send F# code from your current project to the FSI window by highlighting it and pressing
Alt+Enter.
After selecting all the code in Example 1-1 within the code editor and pressing Alt+Enter
you will see the following in the FSI window:
>

val main : string [] -> int

This allows you to write code in the Visual Studio editor – which offers syntax
highlighting and IntelliSense – but test your code using the FSI window. You can check
the main ‘smethod's implementation by calling it from FSI.
> main [| "Hello"; "World" |];;
Hello, World at 10:52 AM
val it : int = 0

The majority of the examples in this book are taken directly from FSI
sessions. I encourage you to use FSI to follow along and experiment
with the F# language’s syntax.
You can find a copy of the source code for all examples in the book on
GitHub at https://github.com/aChrisSmith/Programming-FS-
Examples/.

Managing F# Source Files

When you are starting out with F# programming, most of the programs you write will
live only in FSI or perhaps in a single code file. Your F# projects however will quickly
grow and be broken up across multiple files and eventually multiple projects.
The F# language has some unique characteristics when it comes to managing projects
with multiple source files. In F# the order in which code files are compiled is significant.
You can only call into functions and classes defined earlier in the code file or in a
separate code file compiled before the file where the function or class is used. If you
rearrange the order of the source files your program may no longer build!

The reason for this significance in compilation order is type inference, a

topic covered in the next chapter.

F# source files are compiled from top to bottom in the order they are displayed in Visual
Studio’s Solution Explorer. Whenever you add a new code, file it is added at the bottom

` 8
O’Reilly Media, Inc. 4/2/2012

of the list, but if you want to rearrange the source files you can right click a code file and
select “Move Up” or “Move Down” as seen in Figure 1-5. The keyboard shortcut for
reordering project files is Alt+Up and Alt+Down.

Figure 1-5. Reordering files within an F# project

A feature sorely missing from Visual Studio is the ability to organize

an F# project’s source code files into subfolders. While not exposed by
the Visual Studio UI, you can edit the project file directly to achieve
this. Many of the in-depth examples of this book utilize this technique.

Now that you are armed with the logistical know-how for creating, compiling, and testing
F# applications, the rest of this book will focus exclusively on the syntax and semantics
of the F# programming language.

` 9
O’Reilly Media, Inc. 4/2/2012

In just a few chapters you’ll master the syntax of the F# language as well as be able to
apply it across several programming paradigms. Good luck and have fun!

` 10
O’Reilly Media, Inc. 4/2/2012

2
Fundamentals

In Chapter 1, you wrote your first F# program. I broke it down to give you a feel for what
you were doing, but much of the code is still a mystery. In this chapter, I’ll provide the
necessary foundation for you to understand that code fully, but more importantly, I’ll
present several more examples that you can use to grasp the basics of F# before you
move on to the more complex features.
The first section of this chapter covers primitive types, like int and string, which are
the building blocks for all F# programs. I’ll then cover functions so you can manipulate
data.
The fourth section details foundational types such as list, option, and unit.
Mastering these types will enable you to expand into the object-oriented and functional
styles of F# code covered in later chapters.
By the end of this chapter you will be able to write simple F# programs for processing
data. In future chapters you will learn how to add power and expressiveness to your code,
but for now let’s master the basics.

Primitive Types
A type is a concept or abstraction and is primarily about enforcing safety. Types represent
a proof of sorts if a conversion will work. Some types are straightforward – representing
an integer – while others are far more abstract – like a function. F# is statically typed,
meaning that type checking is done at compile-time. For example, if a function accepts an
integer as a parameter you will get a compiler error if you try to pass in a string.
Like C# and VB.NET, F# supports the full cast and crew of primitive .NET types. (Which
are standard across most programming languages.) They are built into the F# language
and separate from user-defined types which you define yourself.
To create a value, simply use a let binding via the let keyword. For example, the
following code defines a new value x in an FSI session. You can do much more with
let bindings, but we’ll save that for Chapter 3.

1
O’Reilly Media, Inc. 4/2/2012

> let x = 1;;

val x : int = 1

Numeric Primitives
Numeric primitives come in two varieties: integers and floating-point numbers. Integer
types vary by size, so that some types take up less memory and can represent a smaller
range of numbers. Integers can also be signed or unsigned based on whether or not they
can represent negative values.
Floating-point types vary in size too; in exchange for taking up more memory they
provide more precision for the values they hold.
To define new numeric values, use a let binding followed by an integer or floating-
point literal with an optional suffix. The suffix determines the type of integer or floating-
point number. For a full list of available primitive numeric types and their suffixes, see
Table 2-1.
> let answerToEverything = 42UL;;

val answerToEverything : uint64 = 42UL

> let pi = 3.1415926M;;

val pi : decimal = 3.1415926M

> let avogadro = 6.022e23;;

val avogadro : float = 6.022e23

Table 2-1. Numerical primitives in F#

Type Suffix .NET Type Range
byte uy System.Byte 0 to 255
sbyte y System.SByte –128 to 127
int16 s System.Int16 –32,768 to 32,767
uint16 us System.UInt16 0 to 65,535
int, int32 System.Int32 –231 to 231–1
uint32 u System.UInt32 0 to 232–1
int64 L System.Int64 –263 to 263–1
uint64 UL System.UInt64 0 to 264–1
float System.Double A double-precision floating
point based on the IEEE64
standard. Represents values
with approximately 15
significant digits.
float32 f System.Single A single-precision floating
point based on the IEEE32

2
O’Reilly Media, Inc. 4/2/2012

standard. Represents values

with approximately 7
significant digits.
decimal M System.Decimal A fixed-precision floating-
point type with precisely 28
digits of precision.
F# will also allow you to specify values in hexadesimal (base 16), octal (base 8), or
binary (base 2) using a prefix 0x, 0o, or 0b.
> let hex = 0xFCAF;;

val hex : int = 64687

> let oct = 0o7771L;;

val oct : int64 = 4089L

> let bin = 0b00101010y;;

val bin : sbyte = 42y

> (hex, oct, bin);;

val it : int * int64 * sbyte = (64687, 4089L, 42)
If you are familiar with the IEEE32 and IEEE64 standards, you can also specify floating-
point numbers using hex, octal, or binary. F# will convert the binary value to the floating-
point number it represents. When using a different base to represent floating-point
numbers, use the LF suffix for float types and lf for float32 types.
> 0x401E000000000000LF;;
val it : float = 7.5

> 0x00000000lf;;
val it : float32 = 0.0f

Arithmetic
You can use standard arithmetic operators on numeric primitives. Table 2-2 lists all
supported operators. Like most programming languages, integer division rounds down
discarding the remainder.

Table 2-2. Arithmetic operators

Operator Description Example Result
+ Addition 1 + 2 3
- Subtraction 1 – 2 -1
* Multiplication 2 * 3 6
/ Division 8L / 3L 2L

3
O’Reilly Media, Inc. 4/2/2012

** Power 1 2.0 ** 8.0 256.0

% Modulus 7 % 3 1

By default arithmetic operators do not check for overflow, so if you exceed the range
allowed by an integer value by addition it will overflow to be negative. (Similarly,
subtraction will result in a positive number if the number is too small to be stored in the
integer type.)
> 32767s + 1s;;
val it : int16 = -32768s

> -32768s + -1s;;

val it : int16 = 32767s

If integer overflow is a cause for concern, you should consider using a

larger type or using checked arithmetic, discussed in Chapter 7.

F# features all the standard mathematical functions you would expect, with a full listing
in Table 2-3.

Table 2-3. Common mathematical functions

Routine Description Example Result
abs Absolute value of a number abs -1.0 1.0
ceil Round up to the nearest integer ceil 9.1 10.0
exp Raise a value to a power of e. exp 1.0 2.718
floor Round down to the nearest integer floor 9.9 9.0
sign Sign of the value sign -5 -1
log Natural logarithm log 2.71828 1.0
log10 Logarithm in base 10 log10 1000.0 3.0
sqrt Square root sqrt 4.0 2.0
cos Cosine cos 0.0 1.0
sin Sine sin 0.0 0.0
tan Tangent tan 1.0 1.557
pown Compute the power of an integer pown 2L 10 1024L

Conversion Routines
One of the tenets of the F# language is that there are no implicit conversions. This means
that the compiler will not automatically convert primitive data types for you behind the
scenes, such as converting an int16 to an int64. This eliminates subtle bugs by
removing surprise conversions. Instead, to convert primitive values you must use an

1
Power, the ** operator, only works for float and float32 types. To raise the power of an
integer value you must either convert it to a floating-point number first or use the pown function.

4
O’Reilly Media, Inc. 4/2/2012

explicit conversion function listed in Table 2-4. All of the standard conversion functions
accept all other primitive types – including strings and chars.

Table 2-4. Numeric primitive conversion routines

Routine Description Example Result
sbyte Converts data to an sybte sbyte -5 -5y
byte Converts data to a byte byte "42" 42uy
int16 Converts data to an int16 int16 'a' 97s
uint16 Converts data to a unit16 uint16 5 5us
int32, int Converts data to an int int 2.5 2
uint32 Converts data to a uint32 uint32 0xFF 255
int64 Converts data to an int64 int64 -8 -8L
uint64 Converts data to a unit64 uint64 "0xFF" 255UL
float Converts data to a float float 3.1415M 3.1415
float32 Converts data to a float32 float32 8y 8.0f
decimal Converts data to a decimal decimal 1.23 1.23M

While these conversion routines accept strings, they parse strings using
the underling System.Convert family of methods, meaning that for
invalid inputs they throw System.FormatException exceptions.

BigInteger
If you are dealing with data larger than 264 F# has the bigint type for representing
arbitrarily large integers. (bigint type is simply an alias for the
System.Numerics.BigInteger type.)
bigint is integrated into the F# language; by using the I suffix for literals. Example 2-
1 defines data storage sizes as bigints.
Example 2-1. The BigInt type for representing large integers
> open System.Numerics

// Data storage units

let megabyte = 1024I * 1024I
let gigabyte = megabyte * 1024I
let terabyte = gigabyte * 1024I
let petabyte = terabyte * 1024I
let exabyte = petabyte * 1024I
let zettabyte = exabyte * 1024I;;

val megabyte : BigInteger = 1048576

val gigabyte : BigInteger = 1073741824
val terabyte : BigInteger = 1099511627776
val petabyte : BigInteger = 1125899906842624
val exabyte : BigInteger = 1152921504606846976

5
O’Reilly Media, Inc. 4/2/2012

val zettabyte : BigInteger = 1180591620717411303424

Although bigint is heavily optimized for performance, it is much

slower than using the primitive integer data types.

Bitwise Operations
Primitive integer types support bitwise operators for manipulating values at a binary
level. Bitwise operators are typically used when reading and writing binary data from
files. See Table 2-5.

Table 2-5. Bitwise operators

Operator Description Example Result
&&& Bitwise And 0b1111 &&& 0b0011 0b0011
||| Bitwise Or 0xFF00 ||| 0x00FF 0xFFFF
^^^ Bitwise Exclusive Or 0b0011 ^^^ 0b0101 0b0110
<<< Left Shift 0b0001 <<< 3 0b1000
>>> Right Shift 0b1000 >>> 3 0b0001

Characters
The .NET platform is based on Unicode, so most text is represented using 2-byte UTF-16
characters. To define a character value, you can put any Unicode character in single
quotes. Characters can also be specified using a Unicode hexadecimal character code.
The following snippet defines a list of vowel characters and prints the result of defining a
character using a hexadecimal value.
> let vowels = ['a'; 'e'; 'i'; 'o'; 'u'];;

val vowels : char list = ['a'; 'e'; 'i'; 'o'; 'u']

> printfn "Hex u0061 = '%c'" '\u0061';;

Hex u0061 = 'a'
val it : unit = ()
To represent special control characters you need to use an escape sequence, listed in
Table 2-6. An escape sequence is a backslash followed by a special character.

Table 2-6. Character escape sequences

Character Meaning
\' Single quote
\" Double quote

\\ Backslash
\b Backspace
\n Newline

6
Discovering Diverse Content Through
Random Scribd Documents
 GEORGE, PRINCE OF DENMARK
BY CHRISTIAN RICHTER
From the collection of Mr. E. M. Hodgkins

PLATE XII
 MADAME DU BARRY
(1746-1793)
BY RICHARD COSWAY, R.A.
From the collection of Mr. J. Pierpont Morgan

PLATE XIII
 VISCOUNTESS ST. ASAPH (NÉE LADY CHARLOTTE PERCY)
SECOND WIFE OF GEORGE, VISCOUNT ST. ASAPH, AFTERWARDS
THIRD EARL OF ASHBURNHAM
BY RICHARD COSWAY, R.A.
From the collection of Lord Hothfield

PLATE XIV
LADY AUGUSTA MURRAY WIFE OF THE DUKE OF SUSSEX
BY RICHARD COSWAY, R.A.

HENRIETTA, LADY DUNCANNON

AFTERWARDS COUNTESS OF BESSBOROUGH
(Os. 1821)
BY RICHARD COSWAY, R.A.
Both from the collection of Mr. J. Pierpont Morgan

PLATE XV
LUCY, WIFE OF WILLIAM H. NASSAU, FOURTH EARL OF ROCHFORD
BY RICHARD COSWAY, R.A.
From the collection of Lord Hothfield

PLATE XVI
H.R.H. PRINCESS CHARLOTTE OF WALES
(1796-1817)
BY RICHARD COSWAY, R.A.
From the collection of Lord Hothfield

PLATE XVII
HENRY TUFTON, ELEVENTH AND LAST EARL OF THANET
(1775-1849)
BY RICHARD COSWAY, R.A.
From the collection of Lord Hothfield

PLATE XVIII
SIR CHARLES OAKELEY PORTRAIT OF A LADY
(1751-1826) (NAME UNKNOWN)
BY JOHN SMART BY JOHN SMART

Both from the collection of Mr. J. Pierpont Morgan

PLATE XIX

THE HON. EDWARD PERCIVAL, THE HON. MRS. EDWARD

SECOND SON OF JOHN, SECOND EARL OF PERCIVAL
EGMONT BY JOHN SMART
(1744-1824)
BY JOHN SMART (1801)

Both from the collection of Lord Hothfield

PLATE XX
 EARL BEAUCHAMP
BY GEORGE ENGLEHEART (1805)
From the collection of Lady Maria Ponsonby

PLATE XXI
 MISS MARY BERRY
BY GEORGE ENGLEHEART
From the collection of Mr. J. Pierpont Morgan

PLATE XXII
 MRS. SAINTHILL
BY GEORGE ENGLEHEART

JOHN JELLIARD BRUNDISH, M.A.

SMITH PRIZEMAN AND SENIOR WRANGLER IN 1773
BY GEORGE ENGLEHEART
Both from the collection of Lord Hothfield

PLATE XXIII
 REBECCA, LADY NORTHWICK
(Ob. 1818)
BY ANDREW PLIMER
From the collection of Mr. J. Pierpont Morgan

PLATE XXIV
 THE HON. HARRIET RUSHOUT
(Ob. 1851)
BY ANDREW PLIMER

THE HON. ANNE RUSHOUT THE HON. ELIZABETH RUSHOUT

(Ob. 1849) (Ob. 1862
BY ANDREW PLIMER BY ANDREW PLIMER

All from the collection of Mr. J. Pierpont Morgan

PLATE XXV
ELIZABETH, MARGARET CAROLINE AND ANTOINETTE, DAUGHTERS OF JOHN ELLIS, ESQ.
OF HURLINGHAM, MIDDLESEX AND JAMAICA
BY ANDREW PLIMER
All from the collection of Lord Hothfield

PLATE XXVI
 SELINA PLIMER
BY ANDREW PLIMER
From the collection of Dr. G.C. Williamson

PLATE XXVII
 THE SISTERS RUSHOUT
BY ANDREW PLIMER
From the collection of Lord Hothfield

PLATE XXVIII
MRS. BAILEY, WIFE OF LIEUTENANT BAILEY, WHO WAS PRESENT
AT THE STORMING OF SERINGAPATAM IN 1799
BY ANDREW PLIMER
From the collection of Lord Hothfield

PLATE XXIX
SIR CHARLES KENT, BART., AS A CHILD
BY ANDREW PLIMER (1786)
From the collection of Lady Maria Ponsonby

MRS. DAWES
BY NATHANIEL PLIMER (1798)
From the collection of Lord Hothfield

PLATE XXX
CHARLOTTE, DUCHESS OF ALBANY, DAUGHTER OF
CHARLES EDWARD STUART BY CLEMENTINA,
TENTH DAUGHTER OF JOHN WALKENSHAW
(1753-1789)
BY OZIAS HUMPHRY

MARY, WIFE OF THE EIGHTH EARL OF THANET

(Ob. 1778)
BY OZIAS HUMPHRY
Both from the collection of Lord Hothfield

PLATE XXXI
 LIEUTENANT LYGON
BY JOHN SMART, JUN. (1803)
From the collection of Lady Maria Ponsonby

PLATE XXXII
LADY MARY ELIZABETH NUGENT, AFTERWARDS MARCHIONESS
OF BUCKINGHAM, AND IN HER OWN RIGHT,
BARONESS NUGENT
(Ob. 1812)
BY HORACE HONE
From the collection of Lord Hothfield

THE RT. HON. WILLIAM PITT

BY HORACE HONE
From the collection of Lady Maria Ponsonby

PLATE XXXIII
 MISS VINCENT
BY VASLET OF BATH
From the collection of Lord Hothfield

PLATE XXXIV
 THE COUNTESS OF JERSEY
BY SIR GEORGE HAYTER (1819)
From the collection of Lady Maria Ponsonby

PLATE XXXV
 LOUIS XIV
BY JEAN PETITOT, THE ELDER
From the collection of Mr. J. Ward Usher

PLATE XXXVI
 CHARLES I.
BY P. PRIEUR

MARY, DUCHESS OF RICHMOND AND LENOX

(1623-1685)
BY JEAN PETITOT THE ELDER (1643)
Both from the collection of Mr. J. Pierpont Morgan

PLATE XXXVII

MADAME DUPIN
(Ob. 1799)
BY JEAN MARC NATTIER
THE COUNTESS SOPHIE LA PRINCESSE DE LAMBALLE
POTOCKI (Ob. 1792)
(Ob. 1822) BY P. A. HALL
BY P. A. HALL

All from the collection of Mr. J. Pierpont Morgan

PLATE XXXVIII

PORTRAIT OF A BOY
(NAME UNKNOWN)
BY JEAN HONORÉ FRAGONARD
 PORTRAIT OF A LADY
(NAME UNKNOWN)
BY PIERRE PASQUIER (1786)
Both from the collection of Mr. J. Pierpont Morgan

PLATE XXXIX

A GRAND-DAUGHTER OF NATTIER, THE ARTIST

BY LOUIS SICARDI
 LA MARQUISE DE VILLETTE
("BELLE ET BONNE")
BY GARRIOT
Both from the collection of Mr. J. Pierpont Morgan

PLATE XL

THE EMPRESS THE EMPRESS MARIE

JOSEPHINE LOUISE
BY JEAN BAPTISTE BY JEAN BAPTISTE ISABEY
ISABEY

Both from the collection of Mr. J. Ward Usher

PLATE XLI
CATHARINE, COUNTESS BEAUCHAMP
BY JEAN BAPTISTE ISABEY
From the collection of Lady Maria Ponsonby

PLATE XLII
FÜRSTIN KATHARINA BAGRATION SKAWRONSKA
BY JEAN BAPTISTE ISABEY (1812)
From the collection of Fürst Franz Auersperg

PLATE XLIII
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

ebookname.com