Cisternino / Granicz / Syme Expert F#

1. ed
ISBN: 978-1-4302-0285-1
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 609 Seiten

In this book, the world's foremost experts in F# show you how to program in F# the way they do. Written by F#'s inventor and two major contributors to its development, Expert F# is the authoritative, comprehensive, and in-depth guide to the language and its use. Designed to help others become experts, the first part of the book quickly yet carefully describes the F# language. The second part then carefully shows how to elegantly use F# for a wide variety of practical programming tasks. This comprehensive reference of F# concepts, syntax, and features offers a treasury of expert techniques.

Antonio Cisternino is a professor in the Computer Science Department of the University of Pisa. His primary research is on scientific computing, meta-programming and domain-specific languages on virtual-machine-based execution environments. He has been active in the .NET community since 2001 and developed VSLab, a Microsoft Visual Studio add-in to support MATLAB-like programming in F# and Visual Studio. He is also author of annotated C#, an extension of C#, and Robotics4.NET, a framework for programming robots with Microsoft .NET. Cisternino holds a Ph.D. in Computer Science from the University of Pisa.

Autoren/Hrsg.

Cisternino, Antonio

Granicz, Adam

Syme, Don

Inhaltsverzeichnis

1;Contents at a Glance;5
2;Contents;6
3;Foreword;19
4;About the Authors;21
5;About the Technical Reviewer;22
6;Acknowledgments;23
7;Introduction;24
7.1;The Genesis of F#;24
7.2;About This Book;25
7.3;Who This Book Is For;28
8;Getting Started with F# and . NET;30
8.1;Creating Your First F# Program;30
8.2;Using . NET Libraries from F#;43
8.3;Summary;48
9;Introducing Functional Programming;49
9.1;Getting Started with F# Arithmetic;49
9.2;Introducing Simple Strings;53
9.3;Working with Lists and Options;56
9.4;Working with Conditionals: && and ||;61
9.5;Defining Recursive Functions;62
9.6;Introducing Function Values;64
9.7;Getting Started with Pattern Matching;73
9.8;Getting Started with Sequences;77
9.9;Using Sequence Expressions;81
9.10;Exploring Some Simple Type Definitions;84
9.11;Summary;90
10;Introducing Imperative Programming;91
10.1;Imperative Looping and Iterating;92
10.2;Using Mutable Records;94
10.3;Using Mutable Locals;98
10.4;Working with Arrays;99
10.5;Introducing the Imperative . NET Collections;102
10.6;Exceptions and Controlling Them;106
10.7;Having an Effect: Basic I/ O;110
10.8;Working with null Values;116
10.9;Some Advice: Functional Programming with Side Effects;117
10.10;Summary;122
11;Mastering Types and Generics;123
11.1;Understanding Generic Type Variables;123
11.2;Writing Generic Functions;124
11.3;Understanding Some Important Generic Functions;125
11.4;Making Things Generic;130
11.5;Understanding . NET Types;134
11.6;Understanding Subtyping;135
11.7;Troubleshooting Type Inference Problems;140
11.8;Summary;145
12;Working with Objects and Modules;146
12.1;Getting Started with Objects and Members;146
12.2;Using Constructed Classes;149
12.3;Adding Further Object Notation to Your Types;152
12.4;Defining Object Types with Mutable State;158
12.5;Getting Started with Object Interface Types;160
12.6;More Techniques to Implement Objects;165
12.7;Using Modules and Static Members;169
12.8;Extending Existing Types and Modules;171
12.9;Working with F# Objects and . NET Types;172
12.10;Summary;174
13;Encapsulating and Packaging Your Code;175
13.1;Hiding Things Away;176
13.2;Using Namespaces and Modules;181
13.3;Using Signature Types and Files;184
13.4;Creating Assemblies, DLLs, and EXEs;186
13.5;Packaging Applications;193
13.6;Summary;199
14;Mastering F#: Common Techniques;200
14.1;Equality, Hashing, and Comparison;200
14.2;Efficient Precomputation and Caching;203
14.3;Cleaning Up Resources;209
14.4;Stack As a Resource: Tail Calls and Recursion;217
14.5;Events and Wiring;226
14.6;Summary;229
15;Introducing Language-Oriented Programming;230
15.1;Using XML As a Concrete Language Format;231
15.2;Working with Abstract Syntax Representations;236
15.3;Introducing Active Patterns;243
15.4;Embedded Computational Languages with Workflows;249
15.5;Using F# Reflection;264
15.6;Using F# Quotations;268
15.7;Summary;273
16;Using the F# and . NET Libraries;274
16.1;A High- Level Overview;274
16.2;Using the System Types;278
16.3;Using Regular Expressions and Formatting;280
16.4;Using Further F# and . NET Data Structures;285
16.5;Introducing Microsoft. FSharp. Math;287
16.6;Supervising and Isolating Execution;289
16.7;Further Libraries for Reflective Techniques;289
16.8;Some Other . NET Types You May Encounter;291
16.9;Some Other . NET Libraries;292
16.10;Summary;293
17;Working with Windows Forms and Controls;294
17.1;Writing “ Hello, World!” in a Click;294
17.2;Understanding the Anatomy of a Graphical Application;295
17.3;Composing User Interfaces;296
17.4;Drawing Applications;301
17.5;Writing Your Own Controls;306
17.6;Displaying Samples from Sensors;310
17.7;Creating a Mandelbrot Viewer;322
17.8;Summary;334
18;Working with Symbolic Representations;335
18.1;Symbolic Differentiation and Expression Rendering;336
18.2;Verifying Circuits with Propositional Logic;356
18.3;Summary;371
19;Reactive, Asynchronous, and Concurrent Programming;372
19.1;Introducing Some Terminology;373
19.2;Using and Designing Background Workers;374
19.3;Introducing Asynchronous Computations;382
19.4;Passing and Processing Messages;396
19.5;Using Shared- Memory Concurrency;405
19.6;Summary;409
20;Building Web Applications;410
20.1;Serving Static Web Content;410
20.2;Serving Dynamic Web Content with ASP. NET;413
20.3;Using ASP. NET Input Controls;423
20.4;Displaying Data from Databases;426
20.5;Going Further with ASP. NET;429
20.6;Building Ajax Rich Client Applications;439
20.7;Using Web Services;441
20.8;Summary;446
21;Working with Data;447
21.1;Querying In-Memory Data Structures;447
21.2;Using Databases to Manage Data;452
21.3;Working with Databases in Visual Studio;466
21.4;Accessing Relational Data with F# LinqToSql;468
21.5;Working with XML As a Generic Data Format;471
21.6;Summary;475
22;Lexing and Parsing;476
22.1;Processing Line- Based Input;477
22.2;Tokenizing with FsLex;479
22.3;Recursive- Descent Parsing;488
22.4;Parsing with FsYacc;492
22.5;Binary Parsing and Pickling Using Combinators;501
22.6;Summary;504
23;Interoperating with C and COM;505
23.1;Common Language Runtime;505
23.2;Memory Management at Run Time;508
23.3;COM Interoperability;510
23.4;Platform Invoke;521
23.5;Summary;536
24;Debugging and Testing F# Programs;537
24.1;Debugging F# Programs;538
24.2;Debugging and Testing with F# Interactive;547
24.3;Unit Testing;551
24.4;Summary;557
25;Designing F# Libraries;558
25.1;Designing Vanilla . NET Libraries;559
25.2;Understanding Functional Design Methodology;564
25.3;Applying the . NET Design Guidelines to F#;567
25.4;Some Recommended Coding Idioms;573
25.5;Summary;575
26;F# Brief Language Guide;576
27;Index;583