Table Of Content

CYAN YELLOW MAGENTA BLACK PANTONE 123 C BOOKS FOR PROFESSIONALS BY PROFESSIONALS® THE EXPERT’S VOICE® IN F# Don Syme, Adam Granicz, Companion and Antonio Cisternino, Expert F# 2.0 eBook Available Authors of Expert F# Dear Reader, E Functional programming is about concise, beautiful, and powerful code; and as x you master the functional way of thinking you will get a boost in productivity and p great personal enjoyment out of the clarity, compositionality, and brevity of your e programs. In this book, you’ll learn about F# 2.0, an exciting young language that brings r functional programming to .NET. F# 2.0 offers a unique combination of function- t Expert al and object-oriented styles, has complete and seamless interoperability with .NET, and has many features and characteristics of dynamic languages but with F the performance of a compiled language. Expert F# 2.0 is the single most complete and comprehensive guide to the lan- F# 2.0 guage, including all of its advanced features such as active patterns, sequence and computation expressions, quotations, units of measure, and lazy evaluation. # Whether you’re using standard functional features such as pattern matching and recursive functions or some unique F# features such as asynchronous workflows, it becomes natural to write programs that spawn threads, model probabilistic events, perform lightning-fast symbolic or numerical computations, translate and manipulate language representations, describe server and client code for web pages in a single entity, manipulate data using typed queries, draw cus- 2 tom UI controls, and interoperate with components built on unmanaged code, to name only a few. All of these and more are demonstrated by example in this book. Many of the examples are only a few lines long, and all are crafted with care, ready for use in your applications. . For functional programmers, this book is full of treasures and a whole host of practical guidance. If this is your first time with a functional language, look no 0 further—you are in for a treat and a great journey! We wish you bon voyage and lots of fun on your exploration of this language. Take functional programming to the next level Don Syme, Adam Granicz, and Antonio Cisternino while enjoying the benefits of a language based Companion eBook on the .NET Framework THE APRESS ROADMAP Beginning F# Expert F# 2.0 See last page for details on $10 eBook version C i s Don Syme, Adam Granicz, SOURCE CODE ONLINE tG www.apress.com ISBN 978-1-4302-2431-0 ernran Sy Antonio Cisternino 56999 inicm and oze Shelve in .NET User level: 9 781430 224310 Intermediate–Advanced this print for content only—size & color not accurate trim = 7.5" x 9.25" spine = 1.15625" 616 page count Expert F# 2.0 ■ ■ ■ Don Syme, Adam Granicz, and Antonio Cisternino Expert F# 2.0 Copyright © 2010 by Don Syme, Adam Granicz, and Antonio Cisternino All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. ISBN-13 (pbk): 978-1-4302- 2431-0 ISBN-13 (electronic): 978-1-4302-2432-7 Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1 Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. President and Publisher: Paul Manning Lead Editor: Jonathan Hassell Technical Reviewer: André van Meulebrouck Editorial Board: Clay Andres, Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell, Jonathan Gennick, Jonathan Hassell, Michelle Lowman, Matthew Moodie, Duncan Parkes, Jeffrey Pepper, Frank Pohlmann, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Matt Wade, Tom Welsh Coordinating Editor: Anita Castro Copy Editor: Tiffany Taylor Compositor: Mary Sudul Indexer: Brenda Miller Artist: April Milne Cover Designer: Anna Ishchenko Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax 201-348-4505, e-mail orders- [email protected], or visit www.springeronline.com. For information on translations, please e-mail [email protected], or visit www.apress.com. Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/info/bulksales. The information in this book is distributed on an “as is” basis, without warranty. Although every precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work. The source code for this book is available to readers at www.apress.com. You will need to answer questions pertaining to this book in order to successfully download the code. This book is dedicated to the memory of James Huddleston, the editor at Apress who initiated this book project and encouraged the authors with his insights, loyalty, enthusiasm, and humor. Jim passed away in February 2007, an enormous loss to his family, Apress, and the authors. Contents at a Glance Contents...................................................................................................................vi Foreword...............................................................................................................xxi About the Authors................................................................................................xxiii About the Technical Reviewer.............................................................................xxiv Acknowledgments..................................................................................................xv ■ Chapter 1: Introduction........................................................................................1 ■ Chapter 2: Getting Started with F# and .NET........................................................7 ■ Chapter 3: Creating Your First F# Program— Introducing Functional Programming................................................................25 ■ Chapter 4: Introducing Imperative Programming..............................................67 ■ Chapter 5: Mastering Types and Generics.........................................................97 ■ Chapter 6: Working with Objects and Modules................................................123 ■ Chapter 7: Encapsulating and Packaging Your Code.......................................153 ■ Chapter 8: Mastering F#: Common Techniques...............................................175 ■ Chapter 9: Introducing Language-Oriented Programming...............................207 ■ Chapter 10: Using the F# and .NET Libraries....................................................249 ■ Chapter 11: Building Graphical User Interfaces...............................................271 ■ Chapter 12: Working with Symbolic Representations.....................................321 ■ Chapter 13: Reactive, Asynchronous, and Parallel Programming...................355 ■ Chapter 14: Building Smart Web Applications.................................................391 ■ Chapter 15: Working with Data........................................................................435 iv ■ Chapter 16: Lexing and Parsing.......................................................................463 ■ Chapter 17: Interoperating with C and COM....................................................491 ■ Chapter 18: Debugging and Testing F# Programs...........................................523 ■ Chapter 19: Designing F# Libraries..................................................................545 ■ Appendix: F# Brief Language Guide.................................................................563 Index.....................................................................................................................571 v ■ CONTENTS Contents Contents at a Glance................................................................................................iv Foreword...............................................................................................................xxi About the Author.................................................................................................xxiii About the Technical Reviewer.............................................................................xxiv Acknowledgments..................................................................................................xv ■ Chapter 1: Introduction........................................................................................1 The Genesis of F#............................................................................................................1 About This Book...............................................................................................................2 Who This Book Is For.......................................................................................................5 ■ Chapter 2: Getting Started with F# and .NET........................................................7 Creating Your First F# Program.......................................................................................7 Documenting Code Using XMLDocs........................................................................................................9 Using let..................................................................................................................................................9 Understanding Types............................................................................................................................10 Calling Functions..................................................................................................................................11 Lightweight Syntax...............................................................................................................................12 Understanding Scope...........................................................................................................................13 Using Data Structures...........................................................................................................................14 Using Properties and the Dot-Notation.................................................................................................15 Using Tuples.........................................................................................................................................16 Using Imperative Code..........................................................................................................................18 Using .NET Libraries from F#.........................................................................................19 Using open to Access Namespaces and Modules................................................................................20 vi ■ CONTENTS Using new and Setting Properties........................................................................................................21 Fetching a Web Page............................................................................................................................22 Summary.......................................................................................................................24 ■ Chapter 3: Creating Your First F# Program— Introducing Functional Programming................................................................25 Getting Started with F# Arithmetic................................................................................25 Basic Literals........................................................................................................................................25 Arithmetic Operators............................................................................................................................26 Bitwise Operations...............................................................................................................................27 Arithmetic Conversions........................................................................................................................28 Arithmetic Comparisons.......................................................................................................................29 Overloaded Math Functions..................................................................................................................29 Introducing Simple Strings............................................................................................30 Working with String Literals and Primitives.........................................................................................30 Building Strings....................................................................................................................................32 Working with Lists and Options.....................................................................................33 Using F# Lists.......................................................................................................................................33 Using F# Option Values.........................................................................................................................37 Using Option Values for Control............................................................................................................38 Working with Conditionals: && and ||............................................................................38 Defining Recursive Functions........................................................................................39 Introducing Function Values..........................................................................................40 Using Anonymous Function Values.......................................................................................................41 Computing with Aggregate Operators..................................................................................................42 Composing Functions with >>.............................................................................................................44 Building Functions with Partial Application..........................................................................................45 Using Local Functions..........................................................................................................................46 Using Functions as Abstract Values.....................................................................................................47 Iterating with Aggregate Operators......................................................................................................48 Abstracting Control with Functions......................................................................................................48 Using .NET Methods as First-Class Functions......................................................................................49 vii ■ CONTENTS Getting Started with Pattern Matching..........................................................................50 Matching on Structured Values............................................................................................................51 Guarding Rules and Combining Patterns..............................................................................................53 Getting Started with Sequences....................................................................................53 Using Range Expressions.....................................................................................................................54 Iterating a Sequence............................................................................................................................55 Transforming Sequences with Aggregate Operators............................................................................55 Which Types Can Be Used as Sequences?...........................................................................................56 Using Lazy Sequences from External Sources.....................................................................................57 Using Sequence Expressions.........................................................................................58 Creating Sequence Expressions Using for............................................................................................58 Enriching Sequence Expressions with Additional Logic.......................................................................59 Generating Lists and Arrays Using Sequence Expressions..................................................................60 Exploring Some Simple Type Definitions.......................................................................60 Defining Type Abbreviations.................................................................................................................60 Defining Records..................................................................................................................................61 Handling Non-Unique Record Field Names..........................................................................................62 Cloning Records....................................................................................................................................63 Defining Discriminated Unions.............................................................................................................63 Using Discriminated Unions as Records...............................................................................................65 Defining Multiple Types Simultaneously..............................................................................................66 Summary.......................................................................................................................66 ■ Chapter 4: Introducing Imperative Programming..............................................67 Imperative Looping and Interating.................................................................................68 Simple for Loops...................................................................................................................................68 Simple while Loops..............................................................................................................................68 More Iteration Loops over Sequences..................................................................................................69 Using Mutable Records..................................................................................................69 Mutable Reference Cells.......................................................................................................................70 Avoiding Aliasing..................................................................................................................................72 Hiding Mutable Data.............................................................................................................................73 Using Mutable Locals.....................................................................................................74 viii